/*

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

#include <personpresenceinfo.h>

#include <protocolpresencewatchingdatahost.h>

#include <presenceinfo.h>

#include <presenceinfofieldcollection.h>

#include <presenceinfofield.h>

#include <presenceinfofieldvaluetext.h>

#include <presenceinfofieldvalueenum.h>

#include <presenceobjectfactory.h>

#include <presentitygroupmemberinfo.h>

#include <protocolpresencedatahost.h>

#include <protocolpresentitygroupsdatahost.h>

#include <ximpobjectcollection.h>

#include <ximpobjectfactory.h>

#include <ximpprotocolconnectionhost.h>

#include <ximpstatus.h>

#include <ximpidentity.h>

#include <simplefactory.h>

#include <msimplewinfo.h>

#include <msimplewatcher.h>

#include <msimpledocument.h>

#include <msimpleelement.h>

#include "simpleplugincommon.h"

#include "simplepluginentitywatcher.h"

#include "simpleplugindebugutils.h"

#include "simpleplugindata.h"

#include "simpleutils.h"

#include "simplepluginwatcher.h"

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

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

// CSimplePluginEntityWatcher::CSimplePluginEntityWatcher

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

//

CSimplePluginEntityWatcher::CSimplePluginEntityWatcher(

    MSimplePluginConnectionObs& aObs,

    MSimpleConnection& aConn,

    CSimplePluginWatcher& aWatcher

     )

  : iPluginWatcher(aWatcher), iConnObs(aObs), iConnection(aConn),

  iOperation(EPluginIdle)

    {

    }

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

// CSimplePluginEntityWatcher::ConstructL

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

//

void CSimplePluginEntityWatcher::ConstructL( )

    {

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

    }

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

// CSimplePluginEntityWatcher::NewL

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

//

CSimplePluginEntityWatcher* CSimplePluginEntityWatcher::NewL(

    MSimplePluginConnectionObs& aObs,

    MSimpleConnection& aConn,

    CSimplePluginWatcher& aWatcher )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginEntityWatcher: NewL"));

#endif

    CSimplePluginEntityWatcher* self =

        new( ELeave ) CSimplePluginEntityWatcher( aObs, aConn, aWatcher );

    CleanupStack::PushL( self );

    self->ConstructL(  );

    CleanupStack::Pop( self );

    return self;

    }

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

// CSimplePluginEntityWatcher::~CSimplePluginEntityWatcher

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

//

CSimplePluginEntityWatcher::~CSimplePluginEntityWatcher()

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginEntityWatcher: DESTRUCTOR"));

#endif

    if ( iWatcher )

        {

        iWatcher->Close();

        }

    delete iEntityId;

    delete iSimpleEntityId;

    }

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

// CSimplePluginEntityWatcher::StartSubscribeL

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

//

void CSimplePluginEntityWatcher::StartSubscribeL(

    const TDesC8& aPresentityId )

    {

    delete iEntityId;

    iEntityId = NULL;

    iListSubsActive = EFalse;

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginEntityWatcher: -> SubscribeL"));

#endif

    iSimpleId = iWatcher->SubscribeL( aPresentityId, NULL, ETrue, EFalse );

    // Save entity id after successful call

    iEntityId = aPresentityId.AllocL();

    iOperation = EPluginStart;

    }

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

// CSimplePluginEntityWatcher::StartSubscribeListL

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

//

void CSimplePluginEntityWatcher::StartSubscribeListL(

    const TDesC8& aPresentityId )

    {

    delete iEntityId;

    iEntityId = NULL;

    iListSubsActive = ETrue;

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginEntityWatcher: -> SubscribeListL"));

#endif

    iSimpleId = iWatcher->SubscribeListL( aPresentityId, NULL, ETrue, EFalse );

    // Save entity id after successful call

    iEntityId = aPresentityId.AllocL();

    iOperation = EPluginStart;

    }

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

// CSimplePluginEntityWatcher::SetSimpleNameL

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

//

void CSimplePluginEntityWatcher::SetSimpleNameL(

    const TDesC8& aPresentityId )

    {

    delete iSimpleEntityId;

    iSimpleEntityId = NULL;

    // Save entity id after successful call

    iSimpleEntityId = aPresentityId.AllocL();

    }

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

// CSimplePluginEntityWatcher::StopSubscribeL

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

//

void CSimplePluginEntityWatcher::StopSubscribeL(

     )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginEntityWatcher: -> UnsubscribeL"));

#endif

    iSimpleId = iWatcher->UnsubscribeL( );

    iOperation = EPluginStop;

    }

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

// CSimplePluginEntityWatcher::WatcherReqCompleteL

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

//

void CSimplePluginEntityWatcher::WatcherReqCompleteL(

    TInt /*aOpId*/, TInt aStatus )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginEntityWatcher: WatcherReqCompleteL"));

#endif

    TPluginEntityWatcherOperation orig = iOperation;

    iOperation = EPluginIdle;

    CompleteClientReq( aStatus );

    if ( aStatus && ( orig == EPluginStop || orig == EPluginStart) )

        {

#ifdef _DEBUG

        PluginLogger::Log(_L("PluginEntityWatcher: calls DeleteWatcher **"));

#endif

        // Delete this entity as useless

        iPluginWatcher.DeleteWatcher( iEntityId->Des() );

        // Do not call anything, since the method call above deletes this instance.

        }

    }

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

// CSimplePluginEntityWatcher::WatcherNotificationL

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

//

void CSimplePluginEntityWatcher::WatcherNotificationL(

    MSimpleDocument& aDocument )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginEntityWatcher: WatcherNotificationL" ));

#endif

    // No need to check the expiration here since WatcherTerminatedL

    // is called then too.

    MProtocolPresenceWatchingDataHost& watcherHost =

        iConnObs.Host()->ProtocolPresenceDataHost().WatchingDataHost();

    MPresenceInfo* prInfo =  iConnObs.PresenceObjectFactory().NewPresenceInfoLC();

    CSimplePluginData::NotifyToPrInfoL( iConnObs.PresenceObjectFactory(), aDocument, *prInfo );

#ifdef _DEBUG

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

    const MPersonPresenceInfo* pers_debug = prInfo->PersonPresence();

    const MPresenceInfoFieldCollection& coll_debug = pers_debug->Fields();

    TInt count_debug = coll_debug.FieldCount();

    PluginLogger::Log(_L("PluginEntityWatcher: nbr of fields received =%d"), count_debug );

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

#endif

    MXIMPIdentity* identity2 = iConnObs.ObjectFactory().NewIdentityLC();

    HBufC* uniBuffer =

        CnvUtfConverter::ConvertToUnicodeFromUtf8L( *aDocument.EntityURI() );

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

    identity2->SetIdentityL( uniBuffer->Des() );

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

    if ( iListSubsActive )

        {

        // Set Group Id

        HBufC* uniBuffer2 =

            CnvUtfConverter::ConvertToUnicodeFromUtf8L( iEntityId->Des() );

        CleanupStack::PushL( uniBuffer2 );

        MXIMPIdentity* gId = iConnObs.ObjectFactory().NewIdentityLC(); // << gId

        gId->SetIdentityL( uniBuffer2->Des() );

        MXIMPObjectCollection* coll =

            iConnObs.ObjectFactory().NewObjectCollectionLC();    // << coll

       iPluginWatcher.GetEntitiesInListL( uniBuffer2->Des(), *coll );

        MProtocolPresentityGroupsDataHost& groupHost =

            iConnObs.Host()->ProtocolPresenceDataHost().GroupsDataHost();

#ifdef _DEBUG

        PluginLogger::Log(

        _L("PluginEntityWatcher: callback HandlePresentityGroupContentL"));

#endif

        groupHost.HandlePresentityGroupContentL( gId, coll );

        CleanupStack::Pop( 2 ); // >> gId, coll

        CleanupStack::PopAndDestroy( uniBuffer2 );

        // This is done only for first notification for group subscription

        iListSubsActive = EFalse;

        }

    // PrFw Host API callback

#ifdef _DEBUG

    PluginLogger::Log(

        _L("PluginEntityWatcher: callback HandleSubscribedPresentityPresenceL"));

#endif

    watcherHost.HandleSubscribedPresentityPresenceL( identity2, prInfo );

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

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

    }

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

// CSimplePluginEntityWatcher::WatcherListNotificationL

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

//

void CSimplePluginEntityWatcher::WatcherListNotificationL(

    MSimplePresenceList& aList )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginEntityWatcher: WatcherListNotificationL" ));

#endif

    // call all the necessary callbacks, for new data + teminated ones.

    // check out whether fullstate list or not

    TBool fullState( EFalse );

    MProtocolPresenceWatchingDataHost& watcherHost =

        iConnObs.Host()->ProtocolPresenceDataHost().WatchingDataHost();

    RPointerArray<MPresenceInfo> entities;

    RPointerArray<MXIMPIdentity> terminated;

    RPointerArray<MXIMPIdentity> allEntities;

    TRAPD( err, CSimplePluginData::NotifyListToPrInfoL(

        iConnObs.ObjectFactory(), iConnObs.PresenceObjectFactory(),

        aList, entities, allEntities, terminated, fullState ));

    if ( err )

        {

#ifdef _DEBUG

        PluginLogger::Log(_L("PluginEntityWatcher: WatcherListNotificationL error *" ));

#endif

        entities.ResetAndDestroy();

        terminated.ResetAndDestroy();

        allEntities.ResetAndDestroy();

        entities.Close();

        terminated.Close();

        allEntities.Close();

        return;

        }

    CompleteClientReq( KErrNone );

    // Call HandleSubscribedPresentityPresenceL for all users

    TInt counter = entities.Count();

    for ( TInt i = counter-1 ; i>=0; i-- )

        {

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

#ifdef _DEBUG

        const MPersonPresenceInfo* info = entities[i]->PersonPresence();

        const MPresenceInfoFieldCollection& coll_debug = info->Fields();

        TInt count_debug = coll_debug.FieldCount();

        PluginLogger::Log(

            _L("PluginWatcher: callback HandleSubscribedPresentityPresenceL nbrFields=%d"), count_debug );

#endif

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

        watcherHost.HandleSubscribedPresentityPresenceL(

            allEntities[i], entities[i] );

        // Owenership is transferred

        allEntities.Remove(i);

        entities.Remove(i);

        }

    // call SetPresentityPresenceDataSubscriptionStateL for terminated users

    counter = terminated.Count();

    for ( TInt i = counter-1 ; i>=0; i-- )

        {

        MXIMPDataSubscriptionState *state = iConnObs.ObjectFactory().NewDataSubscriptionStateLC();

        state->SetSubscriptionStateL(

            MXIMPDataSubscriptionState::ESubscriptionInactive );

#ifdef _DEBUG

        PluginLogger::Log(

                _L("PluginWatcher: TEST COVERS 1"));

        PluginLogger::Log(

        _L("PluginWatcher: callback SetPresentityPresenceDataSubscriptionStateL"));

#endif

        watcherHost.SetPresentityPresenceDataSubscriptionStateL(

            terminated[i], state, NULL );

        CleanupStack::Pop( 1 ); // state

        // Owenership is transferred

        terminated.Remove(i);

        }

    entities.ResetAndDestroy();

    terminated.ResetAndDestroy();

    allEntities.ResetAndDestroy();

    entities.Close();

    terminated.Close();

    allEntities.Close();

    }

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

// CSimplePluginEntityWatcher::WatcherTerminatedL

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

//

void CSimplePluginEntityWatcher::WatcherTerminatedL(

    TInt /*aOpId*/, TInt /*aReason*/ )

    {

    // Call PrFw Host and  tell to CSimplePluginWatcher that

    // this entity can be deleted.

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginEntityWatcher: WatcherTerminatedL" ));

#endif

    MProtocolPresenceWatchingDataHost& watcherHost =

        iConnObs.Host()->ProtocolPresenceDataHost().WatchingDataHost();

    MXIMPDataSubscriptionState *state = iConnObs.ObjectFactory().NewDataSubscriptionStateLC();

    MXIMPStatus* status = iConnObs.ObjectFactory().NewStatusLC();

    state->SetSubscriptionStateL(

        MXIMPDataSubscriptionState::ESubscriptionInactive );

    status->SetResultCode( KErrCompletion );

    MXIMPIdentity* identity = iConnObs.ObjectFactory().NewIdentityLC();

    HBufC16* buf16 = HBufC16::NewLC( PresentityId().Length());

    buf16->Des().Copy( PresentityId() );

    identity->SetIdentityL( buf16->Des() );

    CleanupStack::PopAndDestroy( buf16 );

#ifdef _DEBUG

    PluginLogger::Log(

    _L("PluginWatcher: callback SetPresentityPresenceDataSubscriptionStateL"));

#endif

    watcherHost.SetPresentityPresenceDataSubscriptionStateL(

        identity, state, status );

    CleanupStack::Pop( 3 ); // identity, status, state

    // Delete this entity as useless

    iPluginWatcher.DeleteWatcher( iEntityId->Des() );

    // Do not call anything, since the method call above deletes this instance.

    }

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

// CSimplePluginEntityWatcher::CompleteClientReq

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

//

void CSimplePluginEntityWatcher::CompleteClientReq( TInt aStatus )

    {

    // complete the open PrFw request immediately here!

    iPluginWatcher.CompleteWatcher( aStatus );

    }

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

// CSimplePluginEntityWatcher::PresentityId

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

//

TPtrC8 CSimplePluginEntityWatcher::PresentityId( )

    {

    return iEntityId ? iEntityId->Des() : TPtrC8();

    }

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

// CSimplePluginEntityWatcher::PrFwRequestId

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

//

TXIMPRequestId CSimplePluginEntityWatcher::PrFwRequestId( )

    {

    return iPrFwId;

    }

// End of file