/*

* Copyright (c) 2006,2007 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:    Simple Engine

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <s32mem.h>

// own simple

#include "msimpleconnection.h"

#include "simpleconnection.h"

#include "simplecommon.h"

#include "simpleenginerequest.h"

#include "msimpledocument.h"

#include "msimplefilterdocument.h"

#include "msimplewatcherobserver.h"

#include "msimplepresencelist.h"

#include "simplewatcher.h"

#include "simpleerrors.h"

#include "simplexmlfactory.h"

#include "simplesipconnection.h"

#ifdef _DEBUG

#include "simpledebugutils.h"

#endif

const TInt KExpandSize = 512;

// ================= MEMBER FUNCTIONS =======================

//

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

// CSimpleWatcher::CSimpleWatcher

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

//

CSimpleWatcher::CSimpleWatcher(

    MSimpleConnection& aConn,

    MSimpleWatcherObserver& aObserver )

: CSimpleClient( aConn ),

  iObserver( aObserver ),

  iResCount(0), iComplete( EFalse ),

  iBuffer(NULL)

    {

    }

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

// CSimpleWatcher::~CSimpleWatcher

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

//

CSimpleWatcher::~CSimpleWatcher()

    {

#ifdef _DEBUG

    TSimpleLogger::Log(_L("Watcher: Destructor this=%d" ), (TInt)this );

#endif

    delete iBuffer;

    }

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

// CSimpleWatcher::ConstructL

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

//

void CSimpleWatcher::ConstructL()

    {

    BaseConstructL();

    iBuffer = CBufFlat::NewL(KExpandSize);   

    }

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

// CSimpleWatcher::NewL

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

//

CSimpleWatcher* CSimpleWatcher::NewL(

    MSimpleConnection& aConn,

    MSimpleWatcherObserver& aObserver )

    {

    CSimpleWatcher* self = new (ELeave) CSimpleWatcher(

        aConn, aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

#ifdef _DEBUG

    TSimpleLogger::Log(_L("Watcher: NewL this=%d" ), (TInt)self );

#endif     

    return self;

    }

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

// CSimpleWatcher::Connection

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

//

const MSimpleConnection& CSimpleWatcher::Connection()

    {

    return iConn;

    }

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

// CSimpleWatcher::SIPStatus

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

//

TUint CSimpleWatcher::SIPStatus()

    {

    return DoSIPStatus();

    }

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

// CSimpleWatcher::SIPRetryAfter

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

//

TUint CSimpleWatcher::SIPRetryAfter()

    {

    return DoRetryAfter();

    }

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

// CSimpleWatcher::SipSubscriptionState

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

//

MSimpleWatcher::TSimpleSipSubscriptionState CSimpleWatcher::SipSubscriptionState()

    {

    MSimpleWatcher::TSimpleSipSubscriptionState retVal = ESimpleStateNone;

    // get the old request

    CSimpleEngineRequest* req = SearchRequests( iSubsId );

    if ( req )

        {

        CSimpleConnection* conn = STATIC_CAST( CSimpleConnection*, &iConn); //lint !e826

        CSimpleSipConnection* engine = conn->Connection();                       

        MSimpleEngineRequest::TSimpleSipSubscriptionState intVal = engine->SipSubscriptionState( *req );

        switch ( intVal )

            {

            case MSimpleEngineRequest::ESimpleStateNone:

                retVal = MSimpleWatcher::ESimpleStateNone;

                break;

            case MSimpleEngineRequest::ESimpleStatePending:

                retVal = MSimpleWatcher::ESimpleStatePending;

                break;

            case MSimpleEngineRequest::ESimpleStateActive:

                retVal = MSimpleWatcher::ESimpleStateActive;

                break;            

            case MSimpleEngineRequest::ESimpleStateTerminated:

            default:

                retVal = MSimpleWatcher::ESimpleStateTerminated;

                break;            

            }

        }  

    return retVal;

    }    

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

// CSimpleWatcher::Close

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

//

void CSimpleWatcher::Close( )

    {

    delete this;

    }

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

// CSimpleWatcher::NewRequestL

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

//

void CSimpleWatcher::NewRequestL( MSimpleEngineRequest& aReq )

    {

    TPtrC8 content = aReq.ResponseData();

    TPtrC8 contType = aReq.ResponseContentType();

    TPtrC8 p8;

    p8.Set( KSimpleDocumentType );

    TInt mySize = p8.Length();

    p8.Set( KSimpleMultipartType );

    TInt mySize2 = p8.Length();

    if (!contType.Left(mySize).CompareF(KSimpleDocumentType))

        {

        MSimpleDocument* d = TSimpleXmlFactory::NewDocumentL( content );

        CleanupClosePushL( *d );

#ifdef _DEBUG

        TSimpleLogger::Log(_L("Watcher: call WatcherNotificationL"));

#endif

        iObserver.WatcherNotificationL( *d );

        CleanupStack::PopAndDestroy( d );

        }

    else if ( !(contType.Left(mySize2).CompareF( KSimpleMultipartType )))

        {

    // Detect the difference between multipart/related cases

    // application/pidf+xml and application/rlmi+xml

        if ( contType.FindF( KSimpleDocumentType ) > 0 )  

            {

            // Multipart for a single presentity having a direct content.            

            MSimpleDocument* d = TSimpleXmlFactory::NewDocumentInMultiPartL(

                content, aReq.ResponseBoundary(), aReq.ResponseStart() );            

            CleanupClosePushL( *d );

#ifdef _DEBUG

            TSimpleLogger::Log(_L("Watcher: call WatcherNotificationL (content)"));

#endif

            iObserver.WatcherNotificationL( *d );

            CleanupStack::PopAndDestroy( d );            

            }

        else

            {

            // Multipart for a presence list.

            MSimplePresenceList* l = TSimpleXmlFactory::NewPresenceListL( 

                content, aReq.ResponseBoundary(), aReq.ResponseStart() );

            CleanupClosePushL( *l );

#ifdef _DEBUG

            TSimpleLogger::Log(_L("Watcher: call WatcherListNotificationL"));

#endif            

            iObserver.WatcherListNotificationL( *l );

            CleanupStack::PopAndDestroy( l );            

            }    

        }

    else

        {

        // Unsupported content type, ignore it.

        }

    }

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

// CSimpleWatcher::Complete

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

//

void CSimpleWatcher::Complete(

    TInt aOpId, TInt aStatus, MSimpleEngineRequest& aReq )

    {   

#ifdef _DEBUG

    TSimpleLogger::Log(_L("Watcher: Complete opid=%d status=%d" ),

    aOpId, aStatus );

#endif

    // FUNCTIONALITY

    // Get

    // - SIP ok + terminated -> WatcherReqCompleteL(ok) + WatcherNotificationL(terminated)

    // - terminated + SIP ok -> WatcherNotificationL(terminated) + WatcherReqCompleteL(ok)

    //

    // Stop

    // - terminated + SIP ok -> WatcherReqCompleteL(ok)

    // - SIP ok + terminated -> WatcherReqCompleteL(ok)    

    //

    // Subscribe

    // - SIP error -> WatcherReqCompleteL(error)

    // - SIP ok + terminated ->

    //    WatcherReqCompleteL(ok) + WatcherNotificationL(terminated) + WatcherTerminated()

    // - SIP ok + active + terminated ->

    //        WatcherReqCompleteL(ok) + WatcherNotificationL(active) +

    //        WatcherNotificationL(terminated) + WatcherTErminated

    // - active + SIP ok + terminated ->

    //        WatcherNotificationL(active) + WatcherReqCompleteL(ok) +

    //        WatcherNotificationL(terminated) + WatcherTerminated

    //

    TBool completeNow( EFalse );

    MSimpleEngineRequest::TSimpleRequest orig = aReq.RequestType();

    if ( orig == MSimpleEngineRequest::EDestroyStart )

        {

        // It's time to delete the request of delayed deletion from both DLLs.

        // Delete immediately from another DLL.

        aReq.ModifyType( MSimpleEngineRequest::EDestroy );

        TRAP_IGNORE( SendReqL( aReq ));

        // Delete from this DLL,

        aReq.Destroy();

        return;

        }

    GetSIPStatus( aOpId );

    // Reset data buffer

    iBuffer->Reset();

    // Set the member to point to stack variable

    TBool destroyed( EFalse );

    iDestroyedPtr = &destroyed;

    MSimpleEngineRequest::TSimpleSIPResponse respMet = aReq.ResponseMethod();

    // Convert KSimpleErrPending to OK when needed

    if ( aStatus == KSimpleErrPending )

        {

        aStatus = KErrNone;

        }

    // Handle SIP notification first

    if ( respMet == MSimpleEngineRequest::ENotify )

        {

        // This is true in notifications. Ignore some responses.

        if ( aStatus == KErrCompletion )

            {

            iResCount++;

            }

        if ( orig != MSimpleEngineRequest::ESubscribeStop )

            {

            TRAP_IGNORE( NewRequestL( aReq ) );

            // Check whether an application has called destructor in callback method.

            // Destructor will handle deletion of all the open requests.

            if ( destroyed )

                {

                return;

                }

            } 

        else if ( iResCount > 1  )

            {

            // Stop request is not completed until ok + Notify(terminated) received.  

            // Error completes the stop reqest without Notification.        

            completeNow = ETrue;

            if ( DoCallReqComplete( aOpId, KErrNone ))

                {

                return;

                }            

            }    

        }

    else

        {

        // SIP Status response or client originated cancellation

        iResCount++;

        if ( aStatus != KErrNone )        

            {

            iResCount++;

            if ( orig == MSimpleEngineRequest::ESubscribeStop )     

                {

                // Any response to stop subscribe is ok.

                aStatus = KErrNone;

                }

            }

        if ( !iComplete && 

              ( orig != MSimpleEngineRequest::ESubscribeStop || 

                orig == MSimpleEngineRequest::ESubscribeStop && iResCount > 1 ) )

            {

            // Stop request is not completed until ok + Notify(terminated) received.  

            // Error completes the stop reqest without Notification.        

            completeNow = ETrue;

            if ( DoCallReqComplete( aOpId, aStatus ))

                {

                return;

                }

            }

        }

    // Delete request when not needed

    if ( iResCount > 1 )

        {

        iRequest = MSimpleEngineRequest::ENone;

        iComplete = EFalse;

        TInt reason = ResponseReason( aReq );

        // Delete corresponding request from another DLL with delay. This decreases

        // the counter of active subscriptions there.

        aReq.ModifyType( MSimpleEngineRequest::EDestroyStart );

        TRAP_IGNORE( SendReqL( aReq ));

        // call WatcherTerminatedL when needed, i.e. no Stop or Get

        if ( orig != MSimpleEngineRequest::ESubscribeStop &&

             orig != MSimpleEngineRequest::ESubscribeGet &&

             !completeNow )

            {

#ifdef _DEBUG

            TSimpleLogger::Log(_L("Watcher: call WatcherTerminatedL opid=%d"),

                aOpId );

#endif

            TRAP_IGNORE( iObserver.WatcherTerminatedL( aOpId, reason ));

            // Check whether an application has called destructor in callback method.

            // Destructor of CSimpleClient base class will handle deletion of

            // all the open requests.

            if ( destroyed )

                {

                return;

                }

            }

        // delete request from this DLL later

        }

    iDestroyedPtr = NULL;

    }

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

// CSimpleWatcher::SubscribeL

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

//

TInt CSimpleWatcher::SubscribeL(

    const TDesC8& aURI,

    MSimpleFilterDocument* aFilter,

    TBool aRefresh,

    TBool aAnonymous  )

    {

    if ( iRequest != MSimpleEngineRequest::ENone )

        {

#ifdef _DEBUG

        TSimpleLogger::Log(_L("Watcher: SubscribeL IN-USE **" ) );

#endif

        User::Leave( KErrInUse );

        }

    IncreaseOpId();

#ifdef _DEBUG

    TSimpleLogger::Log(_L("Watcher: SubscribeL opid=%d" ), iOpId );

#endif

    CSimpleEngineRequest* req = CSimpleEngineRequest::NewL(

        *this, MSimpleEngineRequest::ESubscribe, iOpId );

    CleanupStack::PushL( req );

    req->SetRemoteURIL( aURI );

    req->SetRefresh( aRefresh );

    if ( aAnonymous )

        {

        req->SetAux( 1 );

        }

    // handle optional filter document

    if ( aFilter )

        {

        StreamDocumentL( *req, *aFilter );

        }

    SendReqL( *req );

    iRequestList.AddLast( *req );

    CleanupStack::Pop( req );

    iRequest = MSimpleEngineRequest::ESubscribe;

    iResCount = 0;

    iSubsId = iOpId;

    return iOpId;

    }

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

// CSimpleWatcher::SubscribeListL

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

//

TInt CSimpleWatcher::SubscribeListL(

    const TDesC8& aURI,

    MSimpleFilterDocument* aFilter,

    TBool aRefresh,

    TBool aAnonymous )

    {

    if ( iRequest != MSimpleEngineRequest::ENone )

        {

#ifdef _DEBUG

        TSimpleLogger::Log(_L("Watcher: SubscribeListL IN-USE **" ) );

#endif

        User::Leave( KErrInUse );

        }

    IncreaseOpId();

#ifdef _DEBUG

    TSimpleLogger::Log(_L("Watcher: SubscribeListL opid=%d" ), iOpId);

#endif

    CSimpleEngineRequest* req = CSimpleEngineRequest::NewL(

        *this, MSimpleEngineRequest::ESubscribeLista, iOpId );

    CleanupStack::PushL( req );

    req->SetRemoteURIL( aURI );

    req->SetRefresh( aRefresh );

    if ( aAnonymous )

        {

        req->SetAux( 1 );

        }

    // handle optional filter document

    if ( aFilter )

        {

        StreamDocumentL( *req, *aFilter );

        }

    SendReqL( *req );

    iRequestList.AddLast( *req );

    CleanupStack::Pop( req );

    iRequest = MSimpleEngineRequest::ESubscribeLista;

    iResCount = 0;

    iSubsId = iOpId;

    return iOpId;

    }

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

// CSimpleWatcher::GetPresenceL

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

//

TInt CSimpleWatcher::GetPresenceL(

    const TDesC8& aURI,

    MSimpleFilterDocument* aFilter,

    TBool aAnonymous  )

    {

    if ( iRequest != MSimpleEngineRequest::ENone )

        {

#ifdef _DEBUG

        TSimpleLogger::Log(_L("Watcher: GetPresenceL IN-USE **" ) );

#endif

        User::Leave( KErrInUse );

        }

    IncreaseOpId();

#ifdef _DEBUG

    TSimpleLogger::Log(_L("Watcher: GetPresenceL opid=%d" ), iOpId );

#endif

    CSimpleEngineRequest* req = CSimpleEngineRequest::NewL(

        *this, MSimpleEngineRequest::ESubscribeGet, iOpId );

    CleanupStack::PushL( req );

    req->SetRemoteURIL( aURI );

    if ( aAnonymous )

        {

        req->SetAux( 1 );

        }

    // handle optional filter document

    if ( aFilter )

        {

        StreamDocumentL( *req, *aFilter );

        }