// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// Name        : CSIPRegEventSubscriber.cpp

// Part of     : SIP Profile Agent

// implementation

// Version     : 1.0

//

// INCLUDE FILES

#include "sipfromheader.h"

#include "siptoheader.h"

#include "sipeventheader.h"

#include "siprefresh.h"

#include "sipmessageelements.h"

#include "sipexpiresheader.h"

#include "sipacceptheader.h"

#include "sipcontenttypeheader.h"

#include "sipsubscriptionstateheader.h"

#include "sipretryafterheader.h"

#include "sipresponseelements.h"

#include "siperr.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

_LIT8(KRegEventName, "reg");

_LIT8(KAcceptType, "application");

_LIT8(KAcceptSubtype, "reginfo+xml");

_LIT8(KStateActive, "active");

_LIT8(KStatePending, "pending");

_LIT8(KStateTerminated, "terminated");

_LIT8(KReasonProbation, "probation");

_LIT8(KReasonRejected, "rejected");

_LIT8(KReasonGiveup, "giveup");

_LIT8(KReasonNoresource, "noresource");

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::NewL

// -----------------------------------------------------------------------------

//

CSIPRegEventSubscriber* CSIPRegEventSubscriber::NewL(

    CSIPNotifyXmlBodyParser& aXmlParser,

    CSIPConnection& aConnection,

    MSIPRegistrationContext& aContext,

    CUri8& aUserIdentity,

    MSIPRegEventSubscriberObserver& aObserver,

    CSipProfileAgentConfigExtension& aConfigExtension)

	{

	CSIPRegEventSubscriber* self = 

	    NewLC(aXmlParser,aConnection,aContext,aUserIdentity,aObserver,aConfigExtension);

	CleanupStack::Pop();

	return self;

	}

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::NewLC

// -----------------------------------------------------------------------------

//

CSIPRegEventSubscriber* CSIPRegEventSubscriber::NewLC(

    CSIPNotifyXmlBodyParser& aXmlParser,

    CSIPConnection& aConnection,

    MSIPRegistrationContext& aContext,

    CUri8& aUserIdentity,

    MSIPRegEventSubscriberObserver& aObserver,

    CSipProfileAgentConfigExtension& aConfigExtension)

	{

	CSIPRegEventSubscriber* self = 

	    new(ELeave)CSIPRegEventSubscriber(

	        aXmlParser,aConnection,aContext,aUserIdentity,aObserver,aConfigExtension);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::CSIPRegEventSubscriber

// -----------------------------------------------------------------------------

//

CSIPRegEventSubscriber::CSIPRegEventSubscriber(

    CSIPNotifyXmlBodyParser& aXmlParser,

    CSIPConnection& aConnection,

    MSIPRegistrationContext& aContext,

    CUri8& aUserIdentity,

    MSIPRegEventSubscriberObserver& aObserver,

    CSipProfileAgentConfigExtension& aConfigExtension)

 : iStates(MSIPRegEventContext::EMaxStates),

   iCurrentState(MSIPRegEventContext::ENotSubscribed),

   iXmlParser(aXmlParser),

   iConnection(aConnection),

   iRegistrationContext(aContext),

   iUserIdentity(aUserIdentity),

   iObserver(aObserver),

   iConfigExtension(aConfigExtension)

	{

	}

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::ConstructL

// -----------------------------------------------------------------------------

//

void CSIPRegEventSubscriber::ConstructL()

	{

	InitializeStatesL();

    iReasonProbation = SIPStrings::Pool().OpenFStringL(KReasonProbation);

    iReasonRejected = SIPStrings::Pool().OpenFStringL(KReasonRejected);

    iReasonGiveup = SIPStrings::Pool().OpenFStringL(KReasonGiveup);

    iReasonNoresource = SIPStrings::Pool().OpenFStringL(KReasonNoresource);

    iSubscribeAssoc = CreateSubscribeAssocL();

	}

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::InitializeStatesL

// -----------------------------------------------------------------------------

//	

void CSIPRegEventSubscriber::InitializeStatesL()

    {

	iStates.AppendL(TSIPRegEventStateNotSubscribed(*this),

					sizeof(TSIPRegEventStateNotSubscribed));

	iStates.AppendL(TSIPRegEventStateSubscribing(*this),

					sizeof(TSIPRegEventStateSubscribing));					

	iStates.AppendL(TSIPRegEventStateSubscribed(*this),

					sizeof(TSIPRegEventStateSubscribed));

	iStates.AppendL(TSIPRegEventStateReSubscribing(*this),

					sizeof(TSIPRegEventStateReSubscribing));

    }

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::~CSIPRegEventSubscriber

// -----------------------------------------------------------------------------

//

CSIPRegEventSubscriber::~CSIPRegEventSubscriber()

	{

	delete iSubscribeAssoc;

	delete iClientTransaction;

    iReasonProbation.Close();

    iReasonRejected.Close();

    iReasonGiveup.Close();

    iReasonNoresource.Close();

    delete iCurrentRegInfoElement;

	}

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::SubscribeL

// -----------------------------------------------------------------------------

//	

void CSIPRegEventSubscriber::SubscribeL()

    {

    CurrentState().SubscribeL();

    }

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::DoSubscribeL

// -----------------------------------------------------------------------------

//	

void CSIPRegEventSubscriber::DoSubscribeL()

    {

    CSIPRefresh* refresh = CSIPRefresh::NewLC();

    CSIPMessageElements* message = CreateMessageElementsLC(

            iConfigExtension.ExpiryValueL(TSIPProfileTypeInfo::EIms,

            CSipProfileAgentConfigExtension::EProfileSubscriptionValue));

    CSIPClientTransaction* transaction = 

        iSubscribeAssoc->SendSubscribeL(message,refresh);

    CleanupStack::Pop(message);

    CleanupStack::Pop(refresh);

    delete iClientTransaction;

    iClientTransaction = transaction;

    }

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::ReSubscribeL

// -----------------------------------------------------------------------------

//    

void CSIPRegEventSubscriber::ReSubscribeL()

    {

    CSIPSubscribeDialogAssoc* subscribeAssoc = CreateSubscribeAssocL();

    CleanupStack::PushL(subscribeAssoc);

    CSIPRefresh* refresh = CSIPRefresh::NewLC();

    CSIPMessageElements* message = CreateMessageElementsLC(

            iConfigExtension.ExpiryValueL(TSIPProfileTypeInfo::EIms,

            CSipProfileAgentConfigExtension::EProfileSubscriptionValue));

    CSIPClientTransaction* transaction = 

        subscribeAssoc->SendSubscribeL(message,refresh);    

    CleanupStack::Pop(message);

    CleanupStack::Pop(refresh);

    delete iClientTransaction;

    iClientTransaction = transaction;

    CleanupStack::Pop(subscribeAssoc);

    delete iSubscribeAssoc;

    iSubscribeAssoc = subscribeAssoc;

    }

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::RefreshL

// -----------------------------------------------------------------------------

//	

void CSIPRegEventSubscriber::RefreshL()

    {

    CurrentState().RefreshL();

    }

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::DoRefreshL

// -----------------------------------------------------------------------------

//	

void CSIPRegEventSubscriber::DoRefreshL()

    {

    CSIPMessageElements* message = CreateMessageElementsLC(

            iConfigExtension.ExpiryValueL(TSIPProfileTypeInfo::EIms,

            CSipProfileAgentConfigExtension::EProfileSubscriptionValue));

    CSIPClientTransaction* transaction = iSubscribeAssoc->UpdateL(message);

    CleanupStack::Pop(message);

    delete iClientTransaction;

    iClientTransaction = transaction;

    }

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::ReSubscribeAfterL

// -----------------------------------------------------------------------------

//    

void CSIPRegEventSubscriber::ReSubscribeAfterL(TUint aRetryAfter)

    {

    iObserver.SubscriptionFailedL(aRetryAfter);

    }

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::SubscriptionFailedL

// -----------------------------------------------------------------------------

//    

void CSIPRegEventSubscriber::SubscriptionFailedL()

    {

    iObserver.SubscriptionFailedL();

    }

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::RegEventNotSupportedByNetworkL

// -----------------------------------------------------------------------------

// 

void CSIPRegEventSubscriber::RegEventNotSupportedByNetworkL()

    {

    iObserver.RegEventNotSupportedByNetworkL();

    }

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::ReRegister

// -----------------------------------------------------------------------------

//   

void CSIPRegEventSubscriber::ReRegister()

    {

    iObserver.ReRegister();

    }

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::ChangeState

// -----------------------------------------------------------------------------

//      

void CSIPRegEventSubscriber::ChangeState(TState aNewState)

    {

    iCurrentState = aNewState;

    }

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::HasTransaction

// -----------------------------------------------------------------------------

// 	    

TBool CSIPRegEventSubscriber::HasTransaction(

    const CSIPTransactionBase& aTransaction) const

    {

    return (iClientTransaction && aTransaction == *iClientTransaction);

    }    

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::HasRefresh

// -----------------------------------------------------------------------------

// 	    

TBool CSIPRegEventSubscriber::HasRefresh(

    const CSIPRefresh& aRefresh) const

    {

    return (*iSubscribeAssoc->SIPRefresh() == aRefresh);

    } 

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::HasDialog

// -----------------------------------------------------------------------------

//    

TBool CSIPRegEventSubscriber::HasDialog(const CSIPDialog& aDialog) const

    {

    return (aDialog == iSubscribeAssoc->Dialog());

    }

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::RequestReceivedL

// -----------------------------------------------------------------------------

//	

void CSIPRegEventSubscriber::RequestReceivedL(

    CSIPServerTransaction* aTransaction,

    CSIPDialog& aDialog)

    {

    if (HasDialog(aDialog))

        {

        __ASSERT_ALWAYS(aTransaction, User::Leave(KErrCorrupt));

        __ASSERT_ALWAYS(aTransaction->RequestElements() != NULL, 

                        User::Leave(KErrCorrupt));

        const CSIPRequestElements& request = *(aTransaction->RequestElements());  

        CSIPResponseElements* response = HandleReceivedRequestLC(request);

        if (response->StatusCode() == 200)

            {

            TRAPD(err, ParseXmlL(request));

            if (err == KErrNone)

                {

                TBool terminated = EFalse;

                TInt retryAfter = 0;

                HandleSubscriptionStateL(request,terminated,retryAfter); 

                aTransaction->SendResponseL(response);

                CleanupStack::Pop(response);

                if (terminated)

                    {

                    iObserver.TerminatedL(*iCurrentRegInfoElement,retryAfter);

                    }

                else

                    {

                    iObserver.NotifyReceivedL(*iCurrentRegInfoElement);

                    } 

                }

            else if (err == KErrNoMemory)

                {

                User::Leave(err);

                }

            else

                {

                response->SetStatusCodeL(400);

                response->SetReasonPhraseL(

                    SIPStrings::StringF(SipStrConsts::EPhraseBadRequest));

                aTransaction->SendResponseL(response);

                CleanupStack::Pop(response);               

                } 

            }

        else

            {

            aTransaction->SendResponseL(response);

            CleanupStack::Pop(response);

            }

        delete aTransaction;

        }

    }

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::ResponseReceivedL

// -----------------------------------------------------------------------------

//					           

void CSIPRegEventSubscriber::ResponseReceivedL(

    CSIPClientTransaction& aTransaction)

    {

    if (HasTransaction(aTransaction))

        {

        const CSIPResponseElements* response = aTransaction.ResponseElements();

        __ASSERT_ALWAYS(response != NULL, User::Leave(KErrCorrupt));        

        HandleReceivedResponseL(*response);

        }

    }

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::ErrorOccured

// -----------------------------------------------------------------------------

//

void CSIPRegEventSubscriber::ErrorOccured(

    TInt /*aError*/,

    CSIPTransactionBase& aTransaction)

    {

    if (HasTransaction(aTransaction))

        {

        TRAP_IGNORE(CurrentState().ErrorOccuredL())

        }

    }

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::ErrorOccured

// -----------------------------------------------------------------------------

//    

void CSIPRegEventSubscriber::ErrorOccured(TInt aError,

                                          CSIPDialog& aDialog)

    {

    if (HasDialog(aDialog))

        {

        const CSIPClientTransaction* transaction = 

            iSubscribeAssoc->SIPRefresh()->SIPTransaction();

        if (transaction && aError == KErrSIPTerminatedWithResponse)

            {

            TUint statusCode = transaction->ResponseElements()->StatusCode();

            TUint after = RetryAfterValue(*transaction->ResponseElements());

            TRAP_IGNORE(CurrentState().ResponseReceivedL(statusCode,after))

            }

        else

            {

            TRAP_IGNORE(CurrentState().ErrorOccuredL())

            }

        }

    }    

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::HandleReceivedRequestLC

// -----------------------------------------------------------------------------

//

CSIPResponseElements* CSIPRegEventSubscriber::HandleReceivedRequestLC(

    const CSIPRequestElements& aRequest)

    {

    if (!MethodOK(aRequest) || 

        !ContentTypeOK(aRequest) ||

        !SubscriptionStateOK(aRequest))

        {

        return CSIPResponseElements::NewLC(400,

            SIPStrings::StringF(SipStrConsts::EPhraseBadRequest));

        }

    if (!EventOK(aRequest))

        {

        return CSIPResponseElements::NewLC(489,

            SIPStrings::StringF(SipStrConsts::EPhraseBadEvent));

        }

    return CSIPResponseElements::NewLC(200,

        SIPStrings::StringF(SipStrConsts::EPhraseOk));    

    }

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::HandleReceivedResponseL

// -----------------------------------------------------------------------------

//					           

void CSIPRegEventSubscriber::HandleReceivedResponseL(

    const CSIPResponseElements& aResponse)

    {

    TUint statusCode = aResponse.StatusCode();

    if (statusCode >= 200)

        {

        TUint retryAfter = RetryAfterValue(aResponse);

        delete iClientTransaction;

        iClientTransaction = NULL;

        CurrentState().ResponseReceivedL(statusCode,retryAfter);

        }    

    }

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::RetryAfterValue

// -----------------------------------------------------------------------------

//    

TUint CSIPRegEventSubscriber::RetryAfterValue(

    const CSIPResponseElements& aResponse) const

    {

    TUint retryAfter = 0;

    CSIPRetryAfterHeader* retryAfterHeader = 

        static_cast<CSIPRetryAfterHeader*>(

            FindHeader(aResponse.MessageElements(),

                SIPStrings::StringF(SipStrConsts::ERetryAfterHeader)));

    if (retryAfterHeader)

        {

        retryAfter = retryAfterHeader->RetryAfter();

        }

    return retryAfter;

    }    

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::ParseXmlL

// -----------------------------------------------------------------------------

//    

void CSIPRegEventSubscriber::ParseXmlL(const CSIPRequestElements& aRequest)

    {

    CSIPRegInfoElement* regInfoElement = CSIPRegInfoElement::NewLC();

    iXmlParser.ParseL(regInfoElement,aRequest.MessageElements().Content());

    CleanupStack::Pop(regInfoElement);

    delete iCurrentRegInfoElement;

    iCurrentRegInfoElement = regInfoElement;

    }

// -----------------------------------------------------------------------------

// CSIPRegEventSubscriber::HandleSubscriptionStateL

// -----------------------------------------------------------------------------

//    

void CSIPRegEventSubscriber::HandleSubscriptionStateL(

    const CSIPRequestElements& aRequest,

    TBool& aTerminated,

    TInt& aRetryAfter)

    {

    TBool terminated = EFalse;

    CSIPHeaderBase* header = 

        FindHeader(aRequest.MessageElements(),

            SIPStrings::StringF(SipStrConsts::ESubscriptionStateHeader));

    __ASSERT_ALWAYS(header != NULL, User::Leave(KErrCorrupt));        

    CSIPSubscriptionStateHeader* ssHeader = 

        static_cast<CSIPSubscriptionStateHeader*>(header);

    CSIPRefresh* refresh =