/*

* 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:    SIMPLE Protocol implementation for Presence Framework

*

*/

#include <e32std.h>

#include <utf.h>

#include <personpresenceinfo.h>

#include <presenceinfo.h>

#include <presenceinfofield.h>

#include <presenceinfofieldcollection.h>

#include <presenceinfofieldvaluetext.h>

#include <presenceinfofieldvalueenum.h>

#include <presenceinfofieldvaluebinary.h>

#include <presenceobjectfactory.h>

#include <presencewatcherinfo.h>

#include <presenceerrors.hrh>

#include <servicepresenceinfo.h>

#include <devicepresenceinfo.h>

#include <protocolpresencedatahost.h>

#include <protocolpresencepublishingdatahost.h>

#include <ximpdatasubscriptionstate.h>

#include <ximperrors.hrh>

#include <ximpidentity.h>

#include <ximpobjectcollection.h>

#include <ximpobjectfactory.h>

#include <ximpprotocolconnectionhost.h>

#include <ximpstatus.h>

#include <simplefactory.h>

#include <msimplewinfo.h>

#include <msimplepublisher.h>

#include <msimplewatcher.h>

#include <msimpledocument.h>

#include <msimpleelement.h>

#include <msimplecontent.h>

#include "simpleplugincommon.h"

#include "simplepluginpublisher.h"

#include "simpleplugindebugutils.h"

#include "simpleutils.h"

#include "simplepluginwinfo.h"

#include "simpleplugindata.h"

#include "simplepluginxdmutils.h"

#include "simplepluginconnection.h"

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

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

// CSimplePluginWatcherInfo::CSimplePluginWatcherInfo

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

CSimplePluginWatcherInfo::CSimplePluginWatcherInfo( )

        {}

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

// CSimplePluginWatcherInfo::~CSimplePluginWatcherInfo

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

CSimplePluginWatcherInfo::~CSimplePluginWatcherInfo()

    {

    delete iId;

    delete iSipId;

    }

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

// CSimplePluginWatcherInfo::NewL

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

//

CSimplePluginWatcherInfo* CSimplePluginWatcherInfo::NewL(

   const TDesC8& aId, const TDesC& aSipId )

    {

    CSimplePluginWatcherInfo* self = new (ELeave) CSimplePluginWatcherInfo( );

    CleanupStack::PushL( self );

    self->ConstructL( aId, aSipId );

    CleanupStack::Pop( self );

    return self;

    }

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

// CSimplePluginWatcherInfo::ConstructL

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

//

void CSimplePluginWatcherInfo::ConstructL(

    const TDesC8& aId, const TDesC& aSipId  )

    {

    iId = aId.AllocL();

    iSipId = aSipId.AllocL();

    }

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

// CSimplePluginWatcherInfo::Destroy

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

void CSimplePluginWatcherInfo::Destroy()

    {

    iLink.Deque();

    delete this;

    }

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

// CSimplePluginWatcherInfo::Match

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

TBool CSimplePluginWatcherInfo::Match( const TDesC8& aId, const TDesC& aSipId )

    {

    if ( (!iId->Des().CompareF( aId )) && (!iSipId->Des().CompareF( aSipId)) )

        {

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

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

// CSimplePluginWatcherInfo::SipId

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

TPtrC CSimplePluginWatcherInfo::SipId( )

    {

    return iSipId ? iSipId->Des() : TPtrC();

    }

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

// CSimplePluginPublisher::CSimplePluginPublisher

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

//

CSimplePluginPublisher::CSimplePluginPublisher(

    MSimplePluginSettings& aConnSets,

    MSimplePluginConnectionObs& aObs,

    MSimpleConnection& aConn )

: CActive( CActive::EPriorityStandard ),

  iConnObs(aObs), iConnSets( aConnSets), iConnection(aConn),

  iSubscribed(EFalse), iSubscribedOwn(EFalse), iPublished(EFalse),

  iWatcherList( CSimplePluginWatcherInfo::LinkOffset())

    {

    CActiveScheduler::Add(this);

    }

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

// CSimplePluginPublisher::ConstructL

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

//

void CSimplePluginPublisher::ConstructL( )

    {

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

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

    }

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

// CSimplePluginPublisher::NewL

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

//

CSimplePluginPublisher* CSimplePluginPublisher::NewL(

    MSimplePluginSettings& aConnSets,

    MSimplePluginConnectionObs& aObs,

    MSimpleConnection& aConn )

    {

    CSimplePluginPublisher* self =

        new( ELeave ) CSimplePluginPublisher( aConnSets, aObs, aConn );

    CleanupStack::PushL( self );

    self->ConstructL(  );

    CleanupStack::Pop( self );

    return self;

    }

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

// CSimplePluginPublisher::~CSimplePluginPublisher

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

//

CSimplePluginPublisher::~CSimplePluginPublisher()

    {

    if ( iDocument )

        {

        iDocument->Close();

        }

    if ( iPublisher )

        {

        iPublisher->Close();

        }

    if ( iWatcher )

        {

        iWatcher->Close();

        }

    // delete iWatchers;

    DeleteWatchers();

    }

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

// CSimplePluginPublisher::DeleteWatchers

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

void CSimplePluginPublisher::DeleteWatchers()

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginPublisher: DeleteWatchers" ) );

#endif

    // Delete all buffered transaction requests

    TDblQueIter<CSimplePluginWatcherInfo> rIter( iWatcherList );

    rIter.SetToFirst();

    while ( rIter )

        {

        CSimplePluginWatcherInfo* w = rIter;

        rIter++;

        // delete wathcer info

        w->Destroy();

        }

    }

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

// CSimplePluginPublisher::AddWatcherIfNotExistsL

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

void CSimplePluginPublisher::AddWatcherIfNotExistsL( const TDesC8& aId, const TDesC& aSipId )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginPublisher: AddWatcherIfNotExistsL" ) );

#endif

    TDblQueIter<CSimplePluginWatcherInfo> rIter( iWatcherList );

    rIter.SetToFirst();

    TBool found(EFalse);

    while ( rIter )

        {

        CSimplePluginWatcherInfo* w = rIter;

        rIter++;

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

        if ( found )

            {

            break;

            }

        else

            {

            // continue searching

            }

        }

    if ( !found )

        {

#ifdef _DEBUG

        PluginLogger::Log(_L("PluginPublisher: AddWatcherIfNotExistsL adds a watcher" ) );

#endif

        CSimplePluginWatcherInfo* w = CSimplePluginWatcherInfo::NewL( aId, aSipId );

        iWatcherList.AddLast( *w );

        }

    }

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

// CSimplePluginPublisher::RemoveWatcherIfExistsL

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

void CSimplePluginPublisher::RemoveWatcherIfExistsL( const TDesC8& aId, const TDesC& aSipId )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginPublisher: RemoveWatcherIfExistsL" ) );

#endif

    TDblQueIter<CSimplePluginWatcherInfo> rIter( iWatcherList );

    rIter.SetToFirst();

    TBool found(EFalse);

    while ( rIter )

        {

        CSimplePluginWatcherInfo* w = rIter;

        rIter++;

        // delete wathcer info

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

        if ( found )

            {

#ifdef _DEBUG

            PluginLogger::Log(_L("PluginPublisher: RemoveWatcherIfExistsL removes a watcher" ) );

#endif

            w->Destroy();

            break;

            }

        else

            {

            // continue searching

            }

        }

    }

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

// CSimplePluginPublisher::MakeCurrentWatcherListLC

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

CDesCArrayFlat* CSimplePluginPublisher::MakeCurrentWatcherListLC()

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginPublisher: MakeCurrentWatcherListL" ) );

#endif

    // No one should be added more than once

    const TInt KMyGran = 10;

    CDesCArrayFlat* watchers = new (ELeave) CDesCArrayFlat( KMyGran );

    CleanupStack::PushL( watchers );      // << watchers

    // add user only once here.

    TDblQueIter<CSimplePluginWatcherInfo> rIter( iWatcherList );

    rIter.SetToFirst();

    while ( rIter )

        {

        CSimplePluginWatcherInfo* w = rIter;

        rIter++;

        TInt dummy = 0;

        if ( watchers->Find( w->SipId(), dummy ))

            {

            watchers->AppendL( w->SipId() );

            }

        else

            {

            // continue searching

            }

        }

    return watchers;

    }

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

// CSimplePluginPublisher::DoPublishOwnPresenceL

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

//

void CSimplePluginPublisher::DoPublishOwnPresenceL(

    const MPresenceInfo& aOwnPresence,

    TXIMPRequestId aReqId )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginPublisher: DoPublishOwnPresenceL"));

#endif

    const MPersonPresenceInfo* persInfo = aOwnPresence.PersonPresence();

    // convert data format from PrFW to internal

    if ( !persInfo )

        {

        // Notice: error codes

        CompletePrFwReq( KErrArgument );

        return;

        }

    InitializeSimpleDocumentL( );

    AddSimpleDocumentPersL( persInfo );

    TInt myCount = aOwnPresence.ServicePresenceCount();

    for ( TInt i=0; i < myCount; i++ )

        {

        const MServicePresenceInfo& servInfo = aOwnPresence.ServicePresenceAt(i);

        AddSimpleDocumentServiceL( servInfo );

        }

    myCount = aOwnPresence.DevicePresenceCount();

    for ( TInt i=0; i < myCount; i++ )

        {

        const MDevicePresenceInfo& devInfo = aOwnPresence.DevicePresenceAt(i);

        AddSimpleDocumentDeviceL( devInfo );

        }

    // Ensure that XDM rules exists, the show continues in RunL

    StartXdmOperationL(aReqId );

    iOperation = EPublishOwn;

    }

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

// CSimplePluginPublisher::DoSubscribeOwnPresenceL

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

//

void CSimplePluginPublisher::DoSubscribeOwnPresenceL(

    const MPresenceInfoFilter& /*aPif*/,   // notice: aPif filter not supported

    TXIMPRequestId aReqId )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginPublisher: DoSubscribeOwnPresenceL"));

#endif

    StartXdmOperationL( aReqId );

    iOperation = ESubscribeOwn;

    }

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

// CSimplePluginPublisher::DoUpdateOwnPresenceSubscriptionPifL

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

//

void CSimplePluginPublisher::DoUpdateOwnPresenceSubscriptionPifL(

    const MPresenceInfoFilter& /*aPif*/,

    TXIMPRequestId /*aReqId*/ )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginPublisher: DoUpdateOwnPresenceSubscriptionPifL"));

#endif

    // Notice: aPif filter not supported

    User::Leave( KErrNotSupported );

    }

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

// CSimplePluginPublisher::DoUnsubscribeOwnPresenceL

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

//

void CSimplePluginPublisher::DoUnsubscribeOwnPresenceL(

    TXIMPRequestId aReqId )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginPublisher: DoUnsubscribeOwnPresenceL"));

#endif

    iSubscribedOwn = EFalse;

    TRAPD( err, iSimpleId = iWatcher->UnsubscribeL());

    if ( err )

        {

        User::Leave( CSimplePluginConnection::HarmonizeErrorCode( err ));

        }

    iPrFwId = aReqId;

    iOperation = EUnsubscribeOwn;

    }

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

// CSimplePluginPublisher::DoSubscribePresenceWatcherListL

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

//

void CSimplePluginPublisher::DoSubscribePresenceWatcherListL(

    TXIMPRequestId aReqId )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginPublisher: DoSubscribePresenceWatcherListL"));

#endif

    if ( !iSubscribed )

        {

        TRAPD( err, iConnObs.WinfoHandlerL()->SubscribeWinfoListL( aReqId ));

        if ( err )

            {

            User::Leave( CSimplePluginConnection::HarmonizeErrorCode( err ));

            }

        iSubscribed = ETrue;

        iPrFwId = aReqId;

        iOperation = ESubscribeWinfo;

        }

    else

        {

        iPrFwId = aReqId;

        CompletePrFwReq( KErrNone );

        }

    }

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

// CSimplePluginPublisher::DoUnsubscribePresenceWatcherListL

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

//

void CSimplePluginPublisher::DoUnsubscribePresenceWatcherListL(

    TXIMPRequestId aReqId )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginPublisher: DoUnsubscribePresenceWatcherListL"));

#endif

    if ( iSubscribed )

        {

        TRAPD( err, iConnObs.WinfoHandlerL()->UnsubscribeWinfoListL( aReqId ));

        if ( err )

            {

            User::Leave( CSimplePluginConnection::HarmonizeErrorCode( err ));

            }

        iSubscribed = EFalse;

        iPrFwId = aReqId;

        iOperation = EUnsubscribeWinfo;

        }

    else

        {

        iPrFwId = aReqId;

        CompletePrFwReq( KErrNone );

        }

    }

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

// CSimplePluginPublisher::PublishReqCompleteL

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

//

void CSimplePluginPublisher::PublishReqCompleteL( TInt /*aOpid*/, TInt aStatus )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginPublisher: PublishReqCompleteL("));

#endif

    if ( !aStatus )

        {

        iPublished = ETrue;

        }

    else

        {

        }

    CompletePrFwReq( aStatus );

    }

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

// CSimplePluginPublisher::PublishTerminatedL

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

//

void CSimplePluginPublisher::PublishTerminatedL( TInt /*aOpid*/ )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginPublisher: PublishTerminatedL"));

#endif

    // Notice: nothing to do now in Host APi.

    iPublished = EFalse;

    }

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

// CSimplePluginPublisher::WatcherReqCompleteL

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

//

void CSimplePluginPublisher::WatcherReqCompleteL( TInt /*aOpid*/, TInt aStatus )

    {