/*

* Copyright (c) 2006 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:  IETF SIMPLE Protocol implementation for XIMP Framework

*

*/

#include <e32std.h>

#include <utf.h>

#include <ximpdatasubscriptionstate.h>	  

#include <protocolpresencepublishingdatahost.h>

#include <protocolpresencedatahost.h>

#include <ximpobjectfactory.h>

#include <presenceobjectfactory.h>

#include <presenceinfo.h>

#include <personpresenceinfo.h>

#include <ximpprotocolconnectionhost.h>

#include <ximpstatus.h>

#include <ximperrors.hrh>

#include <ximpidentity.h>

#include <ximpobjectcollection.h>

#include <presencewatcherinfo.h>

#include <simpleutils.h>   // For KSimplePDM

#include <simplefactory.h>

#include <msimpledocument.h>

#include <msimplepublisher.h>

#include <msimplewatcher.h>

#include <msimplewinfo.h>

#include <msimpleelement.h>

#include <msimpleconnection.h>

#include <simpleerrors.h>

#include <avabilitytext.h>

#include "presenceplugincommon.h"

#include "presencepluginpublisher.h"

#include "presencepluginwinfo.h"

#include "presenceplugindata.h"

#include "presencepluginxdmutils.h"

#include "presencepluginwatcherinfo.h"

#include "presenceplugincommon.h"

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

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

// CPresencePluginPublisher::CPresencePluginPublisher()

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

//

CPresencePluginPublisher::CPresencePluginPublisher(

    MPresencePluginConnectionObs& aObs,

    MSimpleConnection& aConn )

    : CActive( CActive::EPriorityStandard ),

    iConnObs(aObs), iConnection(aConn),

    iPublisher( NULL ), iWatcher( NULL ),

    iSubscribed(EFalse), iSubscribedOwn(EFalse), 

    iPublished(EFalse), iRePublish(EFalse),

    iWatcherList( CPresencePluginWatcherInfo::LinkOffset() ) 

    {

    DP_SDA("CPresencePluginPublisher::CPresencePluginPublisher ");

    CActiveScheduler::Add(this);        

    }

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

// CPresencePluginPublisher::ConstructL()

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

//

void CPresencePluginPublisher::ConstructL( CPresencePluginData* aPresenceData )

    {

    DP_SDA("CPresencePluginPublisher::ConstructL ");

    iWatcher = TSimpleFactory::NewWatcherL( iConnection, *this );

    iPublisher = TSimpleFactory::NewPublisherL( iConnection, *this );       

    iPresenceData = aPresenceData;

    }

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

// CPresencePluginPublisher::NewL()

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

//

CPresencePluginPublisher* CPresencePluginPublisher::NewL(

    MPresencePluginConnectionObs& aObs,

    MSimpleConnection& aConn,

    CPresencePluginData* aPresenceData )

    {

    CPresencePluginPublisher* self =

        new( ELeave ) CPresencePluginPublisher( aObs, aConn );

    CleanupStack::PushL( self );

    self->ConstructL( aPresenceData );

    CleanupStack::Pop( self );

    return self;

    }

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

// CPresencePluginPublisher::~CPresencePluginPublisher()

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

//

CPresencePluginPublisher::~CPresencePluginPublisher()

    {

    DP_SDA("CPresencePluginPublisher::~CPresencePluginPublisher");

    if ( iDocument )

        {

        iDocument->Close();

        }

    if ( iPublisher )

        {

        iPublisher->Close();

        }

    if ( iWatcher )

        {

        iWatcher->Close();

        }

    DeleteWatchers();

    }

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

// CPresencePluginPublisher::DeleteWatchers

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

//

void CPresencePluginPublisher::DeleteWatchers()

    {

    DP_SDA("CPresencePluginPublisher::DeleteWatchers");

    // Delete all buffered transaction requests

    TDblQueIter<CPresencePluginWatcherInfo> rIter( iWatcherList );

    rIter.SetToFirst();

    while ( rIter )

        {

        DP_SDA("CPresencePluginPublisher::DeleteWatchers while"); 

        CPresencePluginWatcherInfo* w = rIter;

        rIter++;

        // delete wathcer info

        w->Destroy();

        } 

    DP_SDA("CPresencePluginPublisher::DeleteWatchers end"); 

    } 

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

// CPresencePluginPublisher::AddWatcherIfNotExistsL

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

//

void CPresencePluginPublisher::AddWatcherIfNotExistsL( 

    const TDesC8& aId,

    const TDesC& aSipId )

    {

    DP_SDA("CPresencePluginPublisher::AddWatcherIfNotExistsL");

    // Delete all buffered transaction requests

    TDblQueIter<CPresencePluginWatcherInfo> rIter( iWatcherList );

    rIter.SetToFirst();

    TBool found(EFalse);

    while ( rIter )

        {

        CPresencePluginWatcherInfo* w = rIter;

        rIter++;

        found = w->Match( aId, aSipId );

        if ( found )

            {

            DP_SDA("CPresencePluginPublisher::AddWatcherIfNotExistsL found");

            break;

            }

        }

    if ( !found )

        {

        DP_SDA("CPresencePluginPublisher::AddWatcherIfNotExistsL !found");       

        CPresencePluginWatcherInfo* w =

            CPresencePluginWatcherInfo::NewL( aId, aSipId );

        iWatcherList.AddLast( *w );

        } 

    }

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

// CPresencePluginPublisher::RemoveWatcherIfExistsL

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

//

void CPresencePluginPublisher::RemoveWatcherIfExists( 

    const TDesC8& aId, const TDesC& aSipId )

    {

    DP_SDA("CPresencePluginPublisher::RemoveWatcherIfExistsL");

    // Delete all buffered transaction requests

    TDblQueIter<CPresencePluginWatcherInfo> rIter( iWatcherList );

    rIter.SetToFirst();

    TBool found(EFalse);

    while ( rIter )

        {

        CPresencePluginWatcherInfo* w = rIter;

        rIter++;

        // delete wathcer info

        found = w->Match( aId, aSipId );

        if ( found )

            {         

            w->Destroy();

            break;

            }

        }    

    }  

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

// CPresencePluginPublisher::DoPublishOwnPresenceL()

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

//

void CPresencePluginPublisher::DoPublishOwnPresenceL(

    const MPresenceInfo& aOwnPresence,

    TXIMPRequestId aReqId )

    {

    DP_SDA("CPresencePluginPublisher::DoPublishOwnPresenceL");

    const MPersonPresenceInfo* persInfo = aOwnPresence.PersonPresence();

    if ( !persInfo )

        {

        // Notice: error codes

        CompleteXIMPReq( KErrArgument );

        return;

        }

    InitializeSimpleDocumentL( );    

    AddSimpleDocumentPersL( persInfo ); 

    StartXdmOperationL( aReqId );

    iOperation = EPublishOwn;                 

    DP_SDA("CPresencePluginPublisher::DoPublishOwnPresenceL end");

    }

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

// CPresencePluginPublisher::DoSubscribeOwnPresenceL()

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

//

void CPresencePluginPublisher::DoSubscribeOwnPresenceL(

    const MPresenceInfoFilter& /*aPif*/,   // notice: later

    TXIMPRequestId aReqId )

    {

    DP_SDA("CPresencePluginPublisher::DoSubscribeOwnPresenceL");         

    StartXdmOperationL( aReqId );    

    iOperation = ESubscribeOwn; 

    }

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

// CPresencePluginPublisher::DoUpdateOwnPresenceSubscriptionPifL()

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

//

void CPresencePluginPublisher::DoUpdateOwnPresenceSubscriptionPifL(

    const MPresenceInfoFilter& /*aPif*/,

    TXIMPRequestId /*aReqId*/ )

    {

    // Notice: later

    User::Leave( KErrNotSupported );

    }

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

// CPresencePluginPublisher::DoUnsubscribeOwnPresenceL()

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

//

void CPresencePluginPublisher::DoUnsubscribeOwnPresenceL(

    TXIMPRequestId aReqId )

    {     

    DP_SDA("CPresencePluginPublisher::DoUnsubscribeOwnPresenceL");

    iSubscribedOwn = EFalse;

    iSimpleId = iWatcher->UnsubscribeL();

    iXIMPId = aReqId;

    iOperation = EUnsubscribeOwn;    

    }    

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

// CPresencePluginPublisher::DoSubscribePresenceWatcherListL()

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

//

void CPresencePluginPublisher::DoSubscribePresenceWatcherListL(

    TXIMPRequestId aReqId )

    {

    DP_SDA("CPresencePluginPublisher::DoSubscribePresenceWatcherListL");

    if ( !iSubscribed )

        {    

        DP_SDA("DoSubscribePresenceWatcherListL !Subscribed");    

        iConnObs.WinfoHandlerL()->SubscribeWinfoListL( aReqId );

        iSubscribed = ETrue;

        iXIMPId = aReqId;

        iOperation = ESubscribeWinfo;

        }

    else

        {

        DP_SDA("DoSubscribePresenceWatcherListL else");

        iXIMPId = aReqId;         

        iOperation = ESubscribeWinfo;        

        CompleteXIMPReq( KErrNone );

        } 

    DP_SDA("CPresencePluginPublisher::DoSubscribePresenceWatcherListL end"); 

    }

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

// CPresencePluginPublisher::DoUnsubscribePresenceWatcherListL()

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

//

void CPresencePluginPublisher::DoUnsubscribePresenceWatcherListL(

    TXIMPRequestId aReqId )

    {

    DP_SDA("CPresencePluginPublisher::DoUnsubscribePresenceWatcherListL");

    if ( iSubscribed )

        {

        DP_SDA("DoUnsubscribePresenceWatcherListL: if ( iSubscribed ) - begin");

        iConnObs.WinfoHandlerL()->UnsubscribeWinfoListL( aReqId );

        iSubscribed = EFalse;

        iXIMPId = aReqId;

        iOperation = EUnsubscribeWinfo;        

        DP_SDA("DoUnsubscribePresenceWatcherListL:  if ( iSubscribed ) - end");

        }

    else

        {

        DP_SDA("DoUnsubscribePresenceWatcherListL: iSubscribed ) is false");        

        iXIMPId = aReqId;

        iOperation = EUnsubscribeWinfo; //hameed

        CompleteXIMPReq( KErrNone );

        }

    }

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

// CPresencePluginPublisher::PublishReqCompleteL()

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

//

void CPresencePluginPublisher::PublishReqCompleteL( 

    TInt /*aOpid*/,

    TInt aStatus )

    {

    DP_SDA("CPresencePluginPublisher::PublishReqCompleteL");

    // Notice: make 415 error code conversion here and other 

    //SIP code -> XIMP conversions

    DP_SDA2("PublishReqCompleteL STATUS %d",aStatus );

    if( iConnObs.GetSessionStatus() )

        {

        DP_SDA2("PublishReqComp stopState %d",iConnObs.GetStopPublishState());

        if ( !aStatus && !iConnObs.GetStopPublishState() )

            {

            DP_SDA("CPresencePluginPublisher::PublishReqCompleteL ETrue");

            iPublished = ETrue;

            iConnObs.SetStopPublishState( ETrue );

            }

        // Save E-Tag

        if( !aStatus )

            {

            DP_SDA("CPresencePluginPublisher::PublishReqCompleteL Save ETAG");

            TBuf8<KBufSize255> buf;

            buf.Copy( iPublisher->SIPETag() );

            iConnObs.SetETag( buf );

            }

    	//Do not complete if error republish is true. XIMPFW is not knowing we 

    	//are sending republish.

        if( EFalse == iRePublish && !aStatus )

            {

            //Complete Publish request

            DP_SDA("CPresencePluginPublisher::PublishReqCompleteL complete");

            if( !(iConnObs.IsStopPublishCalled()) )

                {

                DP_SDA("CPresencePluginPublisher::PublishReqCompleteL complete normal");

                // successfull Online / others: store status to cache

                StoreOwnStatusToCacheL( );

                CompleteXIMPReq( aStatus );

                }

            //Complete stopPublish and close session if stopPublish is called

            if( iConnObs.IsStopPublishCalled() )

                {

                DP_SDA("PublishReqCompleteL complete closeSession"); 

                iPresenceData->DeletePresenceVariablesL( iConnObs.ServiceId() );

                // successfull Online / others: store status to cache

                StoreOwnStatusToCacheL( );

                //Complete close session

                CompleteClientReq( aStatus );

                }

            }

        if( EFalse == iRePublish && ( KSimpleErrTemporary == aStatus  ) )

           {

           DP_SDA("PublishReqCompleteL KSimpleErrTemporary"); 

           // Make new publish request without ETag

           CreatePublisherL();        

           iSimpleId = iPublisher->StartPublishL( *iDocument, ETrue );

           }

        else if( EFalse == iRePublish && ( KErrTimedOut == aStatus  ) )

            {

            DP_SDA("PublishReqCompleteL KErrTimedOut"); 

            iPublisher->StopPublishL();

            CompleteXIMPReq( KXIMPErrServicRequestTimeouted );

            }

        else

        	{

        	//Set rePublish flag back to false.

        	iRePublish = EFalse;

        	}

        }

    else

        {

        //Run this case if connection is not good any more

        DP_SDA("PublishReqCompleteL No connect CANCEL");

        Cancel();

        }

    DP_SDA("CPresencePluginPublisher::PublishReqCompleteL end");

    }

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

// CPresencePluginPublisher::PublishTerminatedL()

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

//

void CPresencePluginPublisher::PublishTerminatedL( TInt aOpid )

    {

    DP_SDA("CPresencePluginPublisher::PublishTerminatedL");

    DP_SDA2("CPresencePluginPublisher::PublishTerminatedL opID %d",aOpid );

    DP_SDA2("PublishTerminatedL iSimpleId %d",iSimpleId );

    DP_SDA2("PublishTerminatedL iStatus %d",iStatus.Int() );

    if ( iSimpleId == aOpid && iConnObs.GetSessionStatus() )

        {

        DP_SDA("CPresencePluginPublisher::PublishTerminatedL NewPublish");

        CreatePublisherL();       

        TRAPD( error , iSimpleId = iPublisher->StartPublishL( 

        		*iDocument, ETrue ) );

        if ( KErrNone == error )

            {

            DP_SDA("PublishTerminatedL NewPublish KErrNone");

            iRePublish = ETrue;

            iConnObs.SetStopPublishState( EFalse );

            }        

        }

    else

        {

        DP_SDA("CPresencePluginPublisher::PublishTerminatedL else");

        iPublished = EFalse;

        if( iPublisher )

            {

            iPublisher->Close();

            iPublisher = NULL; 

            }    

        }  

    }   

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

// CPresencePluginPublisher::WatcherReqCompleteL()

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

//

void CPresencePluginPublisher::WatcherReqCompleteL( TInt /*aOpid*/,

    TInt aStatus )

    {

    DP_SDA("CPresencePluginPublisher::WatcherReqCompleteL");

    if ( !aStatus )

        {      

        iSubscribedOwn = ETrue;   

        }

    CompleteXIMPReq( aStatus );       

    }

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

// CPresencePluginPublisher::WatcherNotificationL()

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

//

void CPresencePluginPublisher::WatcherNotificationL( 

    MSimpleDocument& aDocument )

    {       

    // Notice: Do not need to check the expiration here since

    // WatcherTerminatedL is called then too.

    DP_SDA("CPresencePluginPublisher::WatcherNotificationL");

    MProtocolPresencePublishingDataHost& publishHost =

        iConnObs.ProtocolPresenceHost().PublishingDataHost();

    MPresenceInfo* prInfo =

        iConnObs.PresenceObjectFactoryOwn().NewPresenceInfoLC();// << prInfo

    iPresenceData->NotifyToPrInfoL(  

        iConnObs.ObjectFactory(),

        iConnObs.PresenceObjectFactoryOwn(), 

        aDocument,

        *prInfo );

    // XIMP Host API callbacks

    publishHost.HandleSubscribedOwnPresenceL( prInfo );

    CleanupStack::Pop();  // >> prInfo            

    }

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

// CPresencePluginPublisher::WatcherListNotificationL()

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

//

void CPresencePluginPublisher::WatcherListNotificationL( 

    MSimplePresenceList& /*aList*/ )

    {

    //Do nothing now

    DP_SDA("CPresencePluginPublisher::WatcherListNotificationL EMPTY");     

    }

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

// CPresencePluginPublisher::WatcherTerminatedL()

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

//

void CPresencePluginPublisher::WatcherTerminatedL(

    TInt /*aOpId*/, TInt aReason )

    {

    DP_SDA("CPresencePluginPublisher::WatcherTerminatedL");

    iSubscribedOwn = EFalse;    

    MXIMPObjectFactory& myFactory = iConnObs.ObjectFactory();    

    MProtocolPresencePublishingDataHost& publishHost =

        iConnObs.ProtocolPresenceHost().PublishingDataHost();

    MXIMPDataSubscriptionState *state =

        myFactory.NewDataSubscriptionStateLC();

    MXIMPStatus* status = myFactory.NewStatusLC();

    state->SetSubscriptionStateL( 

        MXIMPDataSubscriptionState::ESubscriptionInactive );

    status->SetResultCode( aReason );

    publishHost.SetOwnPresenceDataSubscriptionStateL( state, status );

    CleanupStack::Pop( 2 ); // status, state