/*

* Copyright (c) 2008 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:  Impementation for Presence Cache Server session

*

*/

// INCLUDE FILES

#include <mpresencebuddyinfo2.h>

#include "presenceobjecthelpers.h"

#include "presencecachesession.h"

#include "presencecacheserver.h"

#include "presencetrace.h"

#include "cacheobjecthelpers.h"

#include "presencecacheservicestore.h"

#include "presencecachebuddystore.h"

#include "presencecacheevent.h"

//Include Cache server namespace

using namespace NCacheSrv2;

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

// CPresenceCacheSession::NewL()

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

//

CPresenceCacheSession* CPresenceCacheSession::NewL( CPresenceCacheServer& aServer )

    {

    CPresenceCacheSession* self = CPresenceCacheSession::NewLC( aServer );

    CleanupStack::Pop(self);

    return self;    

    }

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

// CPresenceCacheSession::NewLC()

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

//

CPresenceCacheSession* CPresenceCacheSession::NewLC( CPresenceCacheServer& aServer )

    {

    CPresenceCacheSession* self = new ( ELeave ) CPresenceCacheSession( aServer );

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;    

    }

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

// CPresenceCacheSession::~CPresenceCacheSession()

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

//

CPresenceCacheSession::~CPresenceCacheSession()

    {

    if(iDataPack)

        delete iDataPack;

    if(iDataPackAsync)

        delete iDataPackAsync;

    iBuddypresInfoList.ResetAndDestroy();

    iBuddypresInfoList.Close();

    if(iActiveHelper)

        delete iActiveHelper;

    iServer.DecrementSessions();

    RemoveMySubscriptions(); // remove all subscriptions subscribed by this session

    iSubscribedStores.Close();

    EmptyNotificationQueue();

    iNotifyEvents.Close();

    TRACE_1( _L("CPresenceCacheSession[%d]::~CPresenceCacheSession()"), this );

    }

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

// CPresenceCacheSession::ServiceL()

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

//

void CPresenceCacheSession::ServiceL( const RMessage2& aMessage )

    {

    switch ( aMessage.Function() )

        {

        case NRequest::EPrepReadPresenceInfoSync:

            HandlePrepReadPresenceInfoSyncL(aMessage);

            break;

        case NRequest::EGetLastPreparedPacket:

            HandleGetLastPreparedPacketL(aMessage);

            break;

        case NRequest::EGetLastAsyncPreparedPacket:

            HandleGetLastPreparedAsyncPacketL(aMessage);

            break;

        case NRequest::EBuddyCountInAllServices:

            HandleBuddyCountInAllServicesL(aMessage);

            break;

        case NRequest::EBuddyCountInService:

            HandleBuddyCountInServiceL(aMessage);

            break;

        case NRequest::EGetServiceCount:

            HandleGetServiceCountL(aMessage);

            break;

        case NRequest::EDeleteService:

            HandleDeleteServiceL(aMessage);

            break;

        case NRequest::EDeletePresence:

            HandleDeletePresenceL(aMessage);

            break;

        case NRequest::ECancelAsyncOperation:

            HandleCancel(aMessage);

            break;

        case NRequest::EWritePresenceInfoSync:

            HandleWritePresenceInfoSyncL(aMessage);

            break;

        case NRequest::EWritePresenceInfoAsync:

            HandleWritePresenceInfoAsyncL(aMessage);

            break;

        case NRequest::EPrepReadAllBuddiesPresenceInService:

            HandlePrepReadAllBuddiesPresenceInService(aMessage);

            break;

        case NRequest::ESubscribeBuddyPresenceChange:// 0:aService.iUid, 1:myIdPack

            HandleSubscribeBuddyPresenceChangeL(aMessage);

            break;

        case NRequest::EUnSubscribeBuddyPresenceChange: // 0:aService.iUid, 1:myIdPack

            HandleUnSubscribeBuddyPresenceChangeL(aMessage);

            break;

        case NRequest::EGetLastNotifiedtPacket: // 0:&ptrBuf

            HandleGetLastNotifiedtPacketL(aMessage);

            break;

        case NRequest::EWaitingForNotification: // 0:&sizePckg

            HandleWaitingForNotificationL(aMessage);

            break;

        case NRequest::ECancelWaitingForNotification:

            HandleCancelWaitingForNotification(aMessage);

            break;

        default:

        	TRACE( _L("CPresenceCacheSession::ServiceL - default"));

            aMessage.Complete(KErrArgument);

            break;

        }

    iServer.StartExpiryCheck();

    }

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

// CPresenceCacheSession::HandlePrepReadPresenceInfoSyncL()

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

//

void CPresenceCacheSession::HandlePrepReadPresenceInfoSyncL( const RMessage2& aMessage )

    {

    TRACE( _L("CPresenceCacheSession::HandlePrepReadPresenceInfoSyncL - begin"));

    TInt sizeOfReturnPacket(NULL);

    // unpacking identity

    const TInt pckSize = aMessage.GetDesLengthL(1);

    HBufC* idPack = HBufC::NewLC( pckSize );

    TPtr paramPckPtr = idPack->Des();    

    aMessage.ReadL( 1, paramPckPtr );

    TPtrC serviceName = GetServiceName( paramPckPtr );  

    TPtrC identity( paramPckPtr ); 

    // now processing

    TInt serviceCount = iServer.iPresenceCache.Count();

    MPresenceBuddyInfo2* buddyPresenceInfo(NULL);

    CPresenceCacheBuddyStore* buddyStore(NULL);

    TRACE_1( _L("_______serviceCount[%d]"), serviceCount);

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

        {

        if (!(serviceName.CompareF( (iServer.iPresenceCache[i])->ServiceName())))

            {

            buddyStore = (iServer.iPresenceCache[i])->FindAndGet(identity);

            if(buddyStore)

                buddyPresenceInfo = buddyStore->PresenceBuddyInfo();

            break;

            }

        }

    CleanupStack::PopAndDestroy(idPack);

    TInt err = KErrNotFound;

    TRACE_1( _L("_______buddyPresenceInfo[%d]"), buddyPresenceInfo);

    if (buddyPresenceInfo) // if found

        {

        if(iDataPack)

            delete iDataPack; iDataPack=NULL;

        iDataPack = PackPresenceInfoLC(*buddyPresenceInfo);

        CleanupStack::Pop(iDataPack);

        sizeOfReturnPacket = (iDataPack->Des()).Size();

        err = KErrNone;

        }

    TPckgBuf<TInt> p(sizeOfReturnPacket);

    aMessage.WriteL(2,p);            

    aMessage.Complete(err);

    TRACE( _L("CPresenceCacheSession::HandlePrepReadPresenceInfoSyncL - end"));

    }

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

// CPresenceCacheSession::HandleGetLastPreparedPacketL()

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

//

void CPresenceCacheSession::HandleGetLastPreparedPacketL( const RMessage2& aMessage )

    {

    TRACE( _L("CPresenceCacheSession::HandleGetLastPreparedPacketL() - begin"));

    if(iDataPack)

        aMessage.WriteL(0, *(iDataPack));

    aMessage.Complete(KErrNone);   

    }

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

// CPresenceCacheSession::HandleGetLastPreparedAsyncPacketL()

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

//

void CPresenceCacheSession::HandleGetLastPreparedAsyncPacketL( const RMessage2& aMessage )

    {

    if(iDataPackAsync)

        aMessage.WriteL(0, *(iDataPackAsync));

    aMessage.Complete(KErrNone);   

    }

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

// CPresenceCacheSession::HandleWritePresenceInfoSyncL()

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

//

void CPresenceCacheSession::HandleWritePresenceInfoSyncL(const RMessage2& aMessage )

    {

    TRACE( _L("CPresenceCacheSession::HandleWritePresenceInfoSyncL - begin"));

    TInt err(KErrNone);

    const TInt pckSize = aMessage.GetDesLengthL(0);

    if(iDataPack)

        delete iDataPack; iDataPack=NULL;

    iDataPack = HBufC8::NewL( pckSize );

    TPtr8 paramPckPtr = iDataPack->Des();

    aMessage.ReadL( 0, paramPckPtr );

    MPresenceBuddyInfo2* buddypresenceInfo = MPresenceBuddyInfo2::NewLC();          

    TCacheObjectPacker< MPresenceBuddyInfo2 >::UnPackL(*buddypresenceInfo, *iDataPack);        

    err = TryWriteBuddyToCacheL(buddypresenceInfo);

    if(err==KErrNone || err == KErrNoMemory)  //ownership  transferred

        {

        CleanupStack::Pop();       //buddypresenceInfo

        }

    else       //KErrGeneral, ownership not transferred

        {

        CleanupStack::PopAndDestroy();

        }

    aMessage.Complete(err);

    TRACE( _L("CPresenceCacheSession::HandleWritePresenceInfoSyncL - end"));

    }

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

// CPresenceCacheSession::HandlePrepReadAllBuddiesPresenceInService()

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

//

void CPresenceCacheSession::HandlePrepReadAllBuddiesPresenceInService

                                                        (const RMessage2& aMessage )

    {

    if(iActiveHelper->IsActive())

        aMessage.Complete(KErrServerBusy);

    else

        {

        iMessage = aMessage;

        iAsyncReq = NRequest::EPrepReadAllBuddiesPresenceInService;

        iActiveHelper->Start();

        }

    }

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

// CPresenceCacheSession::ReadAllBuddiesPresenceInServiceL()

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

//

void CPresenceCacheSession::ReadAllBuddiesPresenceInServiceL()

    {

    const TInt pckSize = iMessage.GetDesLengthL(0);

    HBufC* serviceName = HBufC16::NewLC( pckSize );

    TPtr16 paramPckPtr = serviceName->Des();

    iMessage.ReadL( 0, paramPckPtr );

    TInt serviceCount = iServer.iPresenceCache.Count();

    CPresenceCacheServiceStore* serviceStore(NULL);

    CPresenceCacheBuddyStore* buddyStore(NULL);

    MPresenceBuddyInfo2* presBuddyInfo(NULL);

    TInt presCount(0);

    TInt count(0);

    RPointerArray<MPresenceBuddyInfo2> tempArray;

    CleanupClosePushL( tempArray );

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

        {

        serviceStore = iServer.iPresenceCache[i];

        if (!(serviceName->Des().CompareF( serviceStore->ServiceName())))

            {

            presCount = serviceStore->PresenceCount();

            // if it has presences

            if (presCount)

                {

                count = serviceStore->Count();

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

                    {

                    buddyStore = serviceStore->GetObjectCollection()[j];

                    presBuddyInfo = buddyStore->PresenceBuddyInfo();

                    if (presBuddyInfo)

                        {

                        tempArray.AppendL( presBuddyInfo );

                        }

                    }                  

                }

            break;

            }

        }

    TInt size(KErrNotFound); // this may also indicate error to client if negative

    if ( tempArray.Count() ) // if found

        {

        if(iDataPackAsync)

            delete iDataPackAsync; iDataPackAsync = NULL;

        iDataPackAsync = TPresenceArrayPacker::PackArrayL( tempArray );    

        size = (iDataPackAsync->Des()).Size();

        }

    CleanupStack::PopAndDestroy( ); // tempArray    

    CleanupStack::PopAndDestroy(serviceName);

    iAsyncReq = NRequest::ENoRequestMade;

    iMessage.Complete(size);    

    }

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

// CPresenceCacheSession::TryWriteBuddyToCache()

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

//

TInt CPresenceCacheSession::TryWriteBuddyToCacheL(MPresenceBuddyInfo2* aBuddyPresInfo)

    {

    if (!aBuddyPresInfo)

        return KErrArgument;

    TPtrC serviceName = GetServiceName( aBuddyPresInfo->BuddyId() );

    TInt serviceCount = iServer.iPresenceCache.Count();

    CPresenceCacheBuddyStore* buddyStore(NULL);

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

        {

        CPresenceCacheServiceStore* serviceStore = iServer.iPresenceCache[i];

        if ( serviceName.CompareF( serviceStore->ServiceName() ) == 0)

            {

            buddyStore = serviceStore->AddOrReplacePresenceL(aBuddyPresInfo);

            break;

            }

        }

    if (!buddyStore) // if not written

        {

        CPresenceCacheServiceStore* newServiceStore = CPresenceCacheServiceStore::NewLC();

        newServiceStore->SetServiceNameL(serviceName);

        buddyStore = newServiceStore->AddOrReplacePresenceL(aBuddyPresInfo);

        (iServer.iPresenceCache).Append(newServiceStore); //ownership transferred

        CleanupStack::Pop(newServiceStore);

        }

    TInt err = KErrGeneral;

    if (buddyStore)

        {

        TRAP( err, NotifyAllSubscribersL(buddyStore) );

        if (err != KErrNone && err != KErrNoMemory)

            {

            User::LeaveIfError(err);

            }

        // reset expiry time stamp

        PresenceCacheBuddyUtils::ResetBuddyInfoTimeStamp( *aBuddyPresInfo );

        }

    return err;

    }

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

// CPresenceCacheSession::HandleCancel()

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

//

void CPresenceCacheSession::HandleCancel(const RMessage2& aMessage )

    {

    if (iActiveHelper->IsActive())

        iActiveHelper->Cancel(); //see also iActiveHelper->DoCancel()

    aMessage.Complete(KErrNotFound);

    }

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

// CPresenceCacheSession::HandleBuddyCountInAllServicesL()

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

//

void CPresenceCacheSession::HandleBuddyCountInAllServicesL(const RMessage2& aMessage )

    {

    TRACE( _L("CPresenceCacheSession::HandleBuddyCountInAllServices - begin"));

    TInt count(NULL);

    TInt serviceCount = iServer.iPresenceCache.Count();

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

        {

        count = (count) + ((iServer.iPresenceCache[i])->PresenceCount());

        }

    TPckgBuf<TInt> p(count);

    aMessage.WriteL(0,p);               

    aMessage.Complete(KErrNone);

    TRACE( _L("CPresenceCacheSession::HandleBuddyCountInAllServices - end"));

    }

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

// CPresenceCacheSession::HandleBuddyCountInServiceL()

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

//

void CPresenceCacheSession::HandleBuddyCountInServiceL(const RMessage2& aMessage )

    {

    TInt count(NULL);

    const TInt pckSize = aMessage.GetDesLengthL(1);

    HBufC* serviceName = HBufC16::NewLC( pckSize );

    TPtr16 paramPckPtr = serviceName->Des();

    aMessage.ReadL( 1, paramPckPtr );

    TInt serviceCount = iServer.iPresenceCache.Count();

    TInt err(KErrNotFound);

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

        {

        if (!(serviceName->Des().CompareF((iServer.iPresenceCache[i])->ServiceName())))

            {

            count = ((iServer.iPresenceCache[i])->PresenceCount());

            err = KErrNone;

            break;

            }

        }

    CleanupStack::PopAndDestroy(serviceName);

    TPckgBuf<TInt> p(count);

    aMessage.WriteL(0,p);

    aMessage.Complete(err);    

    }

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

// CPresenceCacheSession::HandleDeleteServiceL()

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

//

void CPresenceCacheSession::HandleDeleteServiceL(const RMessage2& aMessage )

    {

    TRACE( _L("CPresenceCacheSession::HandleDeleteServiceL - begin"));

    TInt err(KErrNotFound);

    const TInt pckSize = aMessage.GetDesLengthL(0);

    HBufC* serviceName = HBufC16::NewLC( pckSize );

    TPtr16 paramPckPtr = serviceName->Des();

    aMessage.ReadL( 0, paramPckPtr );

    TInt serviceCount = iServer.iPresenceCache.Count();

    TInt buddyCount(NULL);

    TRACE_1( _L("_______serviceCount[%d]"), serviceCount);

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

        {

        if (!(serviceName->Des().CompareF((iServer.iPresenceCache[i])->ServiceName())))

            {

            (iServer.iPresenceCache[i])->RemoveAllPresences();

            buddyCount = (iServer.iPresenceCache[i])->GetObjectCollection().Count();

            TRACE_1( _L("_______buddyCountAfter[%d]"), buddyCount);

            //if there are no buddies left in this service delete this whole service

            if (buddyCount == 0)

                {

                delete iServer.iPresenceCache[i];

                iServer.iPresenceCache.Remove(i);

                }

            //inform all subscribers

            for(TInt j=0; j < buddyCount; j++)

                {

                NotifyAllSubscribersL((iServer.iPresenceCache[i])->GetObjectCollection()[j]);

                }

            err = KErrNone;

            // break;

            }

        }

    CleanupStack::PopAndDestroy(serviceName);

    aMessage.Complete(err);

    TRACE( _L("CPresenceCacheSession::HandleDeleteServiceL - end"));

    }

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

// CPresenceCacheSession::HandleDeletePresenceL()

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

//

void CPresenceCacheSession::HandleDeletePresenceL(const RMessage2& aMessage )

    {

    const TInt pckSize = aMessage.GetDesLengthL(0);

    HBufC* idPack = HBufC::NewLC( pckSize );

    TPtr paramPckPtr = idPack->Des();

    aMessage.ReadL( 0, paramPckPtr );

    TInt err(KErrNotFound);