/*

* 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 <e32svr.h>

#include <utf.h>

#include <s32strm.h>

#include <ximpprotocolconnectionhost.h>

#include <ximpidentity.h>

#include <ximperrors.hrh>

#include <msimpleconnection.h>

#include <protocolpresentitygroupsdatahost.h>

#include <protocolpresencedatahost.h>

#include <ximpobjectcollection.h>

#include <ximpobjectfactory.h>

#include <presenceobjectfactory.h>

#include "presencepluginvirtualgroup.h"

#include "mpresencepluginconnectionobs.h"

#include "presenceplugincommon.h"

#include "presencepluginwatcher.h"

#include "presencepluginentitywatcher.h"

#include "presencepluginxdmutils.h"

#include "presenceplugindata.h"

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

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

// CPresencePluginWatcher::CPresencePluginWatcher()

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

//

CPresencePluginWatcher::CPresencePluginWatcher(

    MPresencePluginConnectionObs& aObs,

    MSimpleConnection& aConn, CPresencePluginData* aPresenceData )

    : CActive( CActive::EPriorityStandard ),

    iConnObs(aObs), iConnection(aConn), iPresenceData( aPresenceData ),

    iXdmState( EPluginIdle ),iCompleted( ETrue ),

    iOperation( EPluginUndef )

    {

    CActiveScheduler::Add( this );

    }

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

// CPresencePluginWatcher::NewL()

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

//

CPresencePluginWatcher* CPresencePluginWatcher::NewL(

    MPresencePluginConnectionObs& aObs,

    MSimpleConnection& aConn,

    CPresencePluginData* aPresenceData )

    {

    DP_SDA("CPresencePluginWatcher::NewL");

    CPresencePluginWatcher* self =

        new( ELeave ) CPresencePluginWatcher( aObs, aConn, aPresenceData );

    CleanupStack::PushL( self );

    CleanupStack::Pop( self );

    return self;

    }

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

// CPresencePluginWatcher::~CPresencePluginWatcher()

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

//

CPresencePluginWatcher::~CPresencePluginWatcher()

    {

    iWatchers.ResetAndDestroy();

    iWatchers.Close();

    iWatcherCandidates.ResetAndDestroy();

    delete iPresIdentity;

    }

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

// CPresencePluginWatcher::DoSubscribePresentityPresenceL()

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

//

void CPresencePluginWatcher::DoSubscribePresentityPresenceL(

    const MXIMPIdentity& aPresentityId,

    const MPresenceInfoFilter& /*aPif*/,

    TXIMPRequestId aReqId )

    {

    DP_SDA("CPresencePluginWatcher::DoSubscribePresentityPresenceL");

    DP_SDA2(" DoSubscribePresentityPresenceL - identity: %S", 

        &aPresentityId.Identity() );

    iOperation = EPluginSubscribeSingle;

    iXdmState = EPluginIdle;    

    SetPresIdentityL( aPresentityId, ETrue );

    //Saving reguestID

    iXIMPId = aReqId;    

    iCompleted = EFalse;

    HBufC8* pres8 = NULL;

    pres8 =

        CnvUtfConverter::ConvertFromUnicodeToUtf8L( iPresIdentity->Des() );

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

    CPresencePluginEntityWatcher* watcher =

        MatchWatcherL( pres8->Des(), ETrue );      

    watcher->StartSubscribeL( pres8->Des() );

    CleanupStack::PopAndDestroy( pres8 );  // >> pres8

    }

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

// CPresencePluginWatcher::DoPerformSubscribePresentityPresenceL()

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

//

void CPresencePluginWatcher::DoPerformSubscribePresentityPresenceL(

    const MXIMPIdentity& aPresentityId,

    TRequestStatus& aStatus )

    {        

    DP_SDA( "CPresencePluginWatcher::DoPerformSubscribePresentityPresenceL ");

    DP_SDA( " -> From list operation");

    iOperation = EPluginSubscribeByAdding;

    iXdmState = EPluginIdle;    

    SetPresIdentityL( aPresentityId, ETrue );

    iCompleted = EFalse;

    HBufC8* pres8 = NULL;

    pres8 =

        CnvUtfConverter::ConvertFromUnicodeToUtf8L( iPresIdentity->Des() );

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

    CPresencePluginEntityWatcher* watcher =

        MatchWatcherL( pres8->Des(), ETrue );      

    watcher->StartSubscribeL( pres8->Des(), aStatus );

    CleanupStack::PopAndDestroy( pres8 );  // >> pres8

    }

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

// CPresencePluginWatcher::DoUpdatePresentityPresenceSubscriptionPifL()

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

//

void CPresencePluginWatcher::DoUpdatePresentityPresenceSubscriptionPifL(

    const MXIMPIdentity& /*aPresentityId*/,

    const MPresenceInfoFilter& /*aPif*/,

    TXIMPRequestId /*aReqId*/ )

    {

    // Notice: later

    User::Leave( KXIMPErrServiceRequestTypeNotSupported );

    }             

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

// CPresencePluginWatcher::DoUnsubscribePresentityPresenceL()

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

//

void CPresencePluginWatcher::DoUnsubscribePresentityPresenceL(

    const MXIMPIdentity& aPresentityId,

    TXIMPRequestId aReqId )

    {

    DP_SDA("CPresencePluginWatcher::DoUnsubscribePresentityPresenceL");

    SetPresIdentityL( aPresentityId, ETrue );

    iXIMPId = aReqId;  

    iCompleted = EFalse;

    HBufC8* pres8 = NULL;

    pres8 =

        CnvUtfConverter::ConvertFromUnicodeToUtf8L( iPresIdentity->Des() );

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

    CPresencePluginEntityWatcher* watcher =

        MatchWatcherL( pres8->Des(), EFalse );

    if ( !watcher )

        {

        DP_SDA("DoUnsubscribePresentityPresenceL error");

        User::Leave( KErrNotFound ); // Notice: error code

        }

    else

        {

      	DP_SDA("DoUnsubscribePresentityPresenceL stop subscripe");

        watcher->StopSubscribeL();      

        }    

    CleanupStack::PopAndDestroy( pres8 );  // >> pres8   

    }             

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

// CPresencePluginWatcher::DoPerformUnsubscribePresentityPresenceL()

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

//

void CPresencePluginWatcher::DoPerformUnsubscribePresentityPresenceL(

    const MXIMPIdentity& aPresentityId,

    TRequestStatus& aStatus )

    {

    DP_SDA("CPresencePluginWatcher::DoPerformUnsubscribePresentityPresenceL");

    SetPresIdentityL( aPresentityId, ETrue );

    iCompleted = EFalse;

    iOperation = EPluginUnSubscribeByRemoving;

    HBufC8* pres8 = NULL;

    pres8 =

        CnvUtfConverter::ConvertFromUnicodeToUtf8L( iPresIdentity->Des() );

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

    CPresencePluginEntityWatcher* watcher =

        MatchWatcherL( pres8->Des(), EFalse );

    if ( !watcher )

        {

        }

    else

        {

    CleanupStack::PopAndDestroy( pres8 );  // >> pres8

    }

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

// CPresencePluginWatcher::DoSubscribePresentityGroupMembersPresenceL()

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

//

void CPresencePluginWatcher::DoSubscribePresentityGroupMembersPresenceL(

    const MXIMPIdentity& aGroupId,

    const MPresenceInfoFilter& /*aPif*/,

    TXIMPRequestId aReqId )

    {

    DP_SDA("DoSubscribePresentityGroupMembersPresenceL");

    //Subscribe all buddys from virtual group

    iOperation = EPluginSubscribeGroup;

    iXdmState = EPluginIdle;    

    SetPresIdentityL( aGroupId, EFalse );

    iXIMPId = aReqId;

    iCompleted = EFalse;

    StartXdmOperationL();

    }             

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

// CPresencePluginWatcher::

//  DoUpdatePresentityGroupMembersPresenceSubscriptionPifL()

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

//

void CPresencePluginWatcher::

    DoUpdatePresentityGroupMembersPresenceSubscriptionPifL(

    const MXIMPIdentity& /*aGroupId*/,

    const MPresenceInfoFilter& /*aPif*/,

    TXIMPRequestId /*aReqId*/ )

    {

    User::Leave( KErrNotSupported );

    }             

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

// CPresencePluginWatcher::DoUnsubscribePresentityGroupMembersPresenceL()

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

//

void CPresencePluginWatcher::DoUnsubscribePresentityGroupMembersPresenceL(

    const MXIMPIdentity& aGroupId,

    TXIMPRequestId aReqId )

    {

    DP_SDA("DoUnsubscribePresentityGroupMembersPresenceL");

    iOperation = EPluginUnsubscribeGroup;

    iXdmState = EPluginIdle;    

    SetPresIdentityL( aGroupId, EFalse );

    iXIMPId = aReqId;

    iCompleted = EFalse;

    StartXdmOperationL();

    }             

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

// CPresencePluginWatcher::GetInterface()

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

//

TAny* CPresencePluginWatcher::GetInterface(

    TInt32 aInterfaceId,

    TIfGetOps aOptions )

    {

    DP_SDA("CPresencePluginWatcher::GetInterface (......) ");

    if ( aInterfaceId == GetInterfaceId() )

        {

        DP_SDA("GetInterface : aInterfaceId == GetInterfaceId()");

        // caller wants this interface

        MProtocolPresenceWatching* myIf = this;

        return myIf;

        }

    if ( aOptions == MXIMPBase::EPanicIfUnknown )

        {

        DP_SDA("GetInterface: aOptions == MXIMPBase::EPanicIfUnknown");

        User::Panic( KPluginName, KErrExtensionNotSupported );

        }  

    return NULL;

    }

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

// CPresencePluginWatcher::GetInterface()

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

//

const TAny* CPresencePluginWatcher::GetInterface(

    TInt32 aInterfaceId,

    TIfGetOps aOptions ) const

    {

    DP_SDA("CPresencePluginWatcher::GetInterface (......) const ");

    if ( aInterfaceId == GetInterfaceId() )

        {

        DP_SDA("GetInterface : aInterfaceId == GetInterfaceId()");

        // caller wants this interface

        const MProtocolPresenceWatching* myIf = this;

        return myIf;

        }

    if ( aOptions == MXIMPBase::EPanicIfUnknown )

        {

        DP_SDA("GetInterface: aOptions == MXIMPBase::EPanicIfUnknown");

        User::Panic( KPluginName, KErrExtensionNotSupported );

        }  

    return NULL;

    }

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

// CPresencePluginWatcher::GetInterfaceId()

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

//

TInt32 CPresencePluginWatcher::GetInterfaceId() const

    {

    DP_SDA("CPresencePluginWatcher::GetInterfaceId() const");

    return MProtocolPresenceWatching::KInterfaceId;

    }

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

// CPresencePluginWatcher::MatchWatcherL

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

//

CPresencePluginEntityWatcher* CPresencePluginWatcher::MatchWatcherL( 

    const TDesC8& aPresentityid, TBool aCreate )

    {

    DP_SDA("CPresencePluginWatcher::MatchWatcherL");

    DP_SDA2("CPresencePluginWatcher::MatchWatcherL %d", aCreate )

    TInt count = iWatchers.Count();

    DP_SDA2( "MatchWatcherL watcher count %d", count );

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

        {

        CPresencePluginEntityWatcher* temp = ( iWatchers[i] );

        //Check if prentity found from watcher

        if ( !temp->PresentityId().CompareF( aPresentityid ))

            {

            DP_SDA("CPresencePluginWatcher::MatchWatcherL return temp");

            return temp;

            }

        }

    if ( !aCreate )

        {

        DP_SDA("CPresencePluginWatcher::MatchWatcherL return NULL");

        return NULL;

        }

    else

        {

        // Run this if like create new wathcer

        DP_SDA("CPresencePluginWatcher::MatchWatcherL Else");                

        CPresencePluginEntityWatcher* watcher =

            CPresencePluginEntityWatcher::NewL( 

            		iConnObs, iConnection, *this, iPresenceData );

        iWatcherCandidates.Append( watcher );

        DP_SDA("CPresencePluginWatcher::MatchWatcherL end");

        return watcher;

        }

    }    

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

// CPresencePluginWatcher::DeleteWatcher

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

//

void CPresencePluginWatcher::DeleteWatcher(

    const TDesC8& aPresentityid )

    {

    DP_SDA( "CPresencePluginWatcher::DeleteWatcher" );

    TInt count = iWatchers.Count();

    DP_SDA2( "CPresencePluginWatcher::DeleteWatcher count %d", count);

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

        {

        CPresencePluginEntityWatcher* temp = ( iWatchers[i] );

        if ( !temp->PresentityId().CompareF( aPresentityid ) )

            {

            DP_SDA2( "CPresencePluginWatcher::DeleteWatcher %d", i );

            iWatchers.Remove( i );

            iWatchers.GranularCompress();

            delete temp;

            temp = NULL;

            break; // delete all watchers?

            }

        }

    DP_SDA( "CPresencePluginWatcher::DeleteWatcher end" );

    }

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

// CPresencePluginWatcher::SetPresIdentityL()

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

//

void CPresencePluginWatcher::SetPresIdentityL(

     const MXIMPIdentity& aPresentityId,

     TBool aFormatUri )

    {

    DP_SDA2("CPresencePluginWatcher::SetPresIdentityL: %S", 

        &aPresentityId.Identity() ); 

    delete iPresIdentity;

    iPresIdentity = NULL;

    if( aFormatUri )

        {

        HBufC8* identityCopy = HBufC8::NewLC( KBufSize255 );

        TPtr8 identityCopyPtr( identityCopy->Des() );

        identityCopyPtr.Copy( aPresentityId.Identity() );

        DP_SDA2(" SetPresIdentityL, org identity: %S", identityCopy );

        HBufC8* prefixUri = iPresenceData->CreatePresenceUri8LC( 

            identityCopyPtr );

        HBufC* prefixUri16 = HBufC::NewLC( KBufSize255 );

        TPtr prefixUri16Ptr( prefixUri16->Des() );

        prefixUri16Ptr.Copy( *prefixUri );

        DP_SDA2("CPresencePluginWatcher::SetPresIdentityL: with prefix: %S", 

            prefixUri16 ); 

        iPresIdentity = prefixUri16;

        CleanupStack::Pop( prefixUri16 );

        CleanupStack::PopAndDestroy( 2, identityCopy );

        }

    else

        {

        DP_SDA("CPresencePluginWatcher::SetPresIdentityL, use as it is");

        iPresIdentity = aPresentityId.Identity().AllocL();

        }

    } 

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

// CPresencePluginWatcher::CompleteXIMPReq()

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

//

void CPresencePluginWatcher::CompleteXIMPReq( TInt aStatus )

    {

    DP_SDA("CPresencePluginWatcher::CompleteXIMPReq"); 

    iXdmState = EPluginIdle;

    if ( iCompleted )

        {

        return;

        }

    iCompleted = ETrue;

    iConnObs.CompleteReq( iXIMPId, aStatus );

    iXIMPId = TXIMPRequestId();

    DP_SDA("CPresencePluginWatcher::CompleteXIMPReq END");

    iOperation = EPluginUndef;    

    }

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

// CPresencePluginWatcher::MatchWatcherId

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

//

TBool CPresencePluginWatcher::MatchWatcherId(

    const TDesC8& aPresentityId ) const

    {

    DP_SDA("CPresencePluginWatcher::MatchWatcherId");

    TBool watcherFound( EFalse );

    TInt count = iWatchers.Count();

    DP_SDA2("CPresencePluginWatcher::MatchWatcherId watcher count %d", count);

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

        {

        CPresencePluginEntityWatcher* temp = ( iWatchers[i] );

        //Check if ID is found from watcher

        if ( !temp->PresentityId().CompareF( aPresentityId ) )

            {

            DP_SDA("CPresencePluginWatcher::MatchWatcherId - Match!");

            watcherFound = ETrue;

            }

        }

    return watcherFound;

    }

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

// CPresencePluginWatcher::CompleteWatcher

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

//

void CPresencePluginWatcher::CompleteWatcher( TInt aStatus )

    {

    DP_SDA("CPresencePluginWatcher::CompleteWatcher");

    DP_SDA2("CPresencePluginWatcher::CompleteWatcher status %d", aStatus);

    // start to remove RLS service when needed.

    if ( iOperation == EPluginUnsubscribeGroup )

        {

        DP_SDA("CompleteWatcher EPluginUnsubscribeGroup");

        if ( iXdmState == EPluginIdle )

            {

            TRAPD( err, iXdmUtils->InitializeXdmsOnlyL( iStatus ));

            if ( err )

                {

                DP_SDA2("CompleteWatcher EPluginUnsubscribeGroup err %d",err);

                CompleteXIMPReq( err );                 

                }

            else

                {

                DP_SDA("CompleteWatcher EPluginUnsubscribeGroup fetch RLS");