/*

* Copyright (c) 2007, 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 <presenceobjectfactory.h>

#include <personpresenceinfo.h>

#include <presencebuddyinfo.h>

#include <presencebuddyinfolist.h>

#include <presenceinfofieldcollection.h>

#include "presencecachesession.h"

#include "presencecacheserver.h"

#include "ximptrace.h"

#include "ximpobjecthelpers.h"

#include "presenceinfoimp.h"

#include "presencebuddyinfolistimp.h"

#include "presencebuddyinfoimp.h"

#include "ximpidentityimp.h"

#include "presencecacheservicestore.h"

#include "presencecachebuddystore.h"

//Include Cache server namespace

using namespace NCacheSrv;

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

// 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;

    if(iDataPackNotifier)

        delete iDataPackNotifier;

    if(iBuddypresInfoList)

        delete iBuddypresInfoList;

    if(iActiveHelper)

        delete iActiveHelper;

    iServer.DecrementSessions();

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

    iSubscribedStores.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:

            HandleBuddyCountInAllServices(aMessage);

            break;

        case NRequest::EBuddyCountInService:

            HandleBuddyCountInService(aMessage);

            break;

        case NRequest::EGetServiceCount:

            HandleGetServiceCount(aMessage);

            break;

        case NRequest::EDeleteService:

            HandleDeleteService(aMessage);

            break;

        case NRequest::EDeletePresence:

            HandleDeletePresence(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

            HandleSubscribeBuddyPresenceChange(aMessage);

            break;

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

            HandleUnSubscribeBuddyPresenceChange(aMessage);

            break;

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

            HandleGetLastNotifiedtPacketL(aMessage);

            break;

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

            HandleWaitingForNotification(aMessage);

            break;

        case NRequest::ECancelWaitingForNotification:

            HandleCancelWaitingForNotification(aMessage);

            break;

        default:

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

            aMessage.Complete(KErrArgument);

            break;

        }

    }

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

// CPresenceCacheSession::HandlePrepReadPresenceInfoSyncL()

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

//

void CPresenceCacheSession::HandlePrepReadPresenceInfoSyncL( const RMessage2& aMessage )

    {

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

    TInt sizeOfReturnPacket(NULL);

    // unpacking identity

    const TInt pckSize = aMessage.GetDesLengthL(1);

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

    TPtr8 paramPckPtr = idPack->Des();

    aMessage.ReadL( 1, paramPckPtr );

    CXIMPIdentityImp* identity = CXIMPIdentityImp::NewLC();

    TXIMPObjectPacker< CXIMPIdentityImp >::UnPackL(*identity, *idPack);

    TPtrC serviceName = GetServiceName(identity->Identity());

    // now processing

    TInt serviceCount = iServer.iPresenceCache.Count();

    MPresenceBuddyInfo* buddyPresenceInfo(NULL);

    CPresenceCacheBuddyStore* buddyStore(NULL);

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

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

        {

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

            {

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

            if(buddyStore)

                buddyPresenceInfo = buddyStore->PresenceBuddyInfo();

            break;

            }

        }

    CleanupStack::PopAndDestroy(identity);

    CleanupStack::PopAndDestroy(idPack);

    TInt err = KErrNotFound;

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

    if(buddyPresenceInfo) // if found

        {

        const CPresenceInfoImp* presInfo = 

            TXIMPGetImpClassOrPanic< const CPresenceInfoImp >::From(*(buddyPresenceInfo->PresenceInfo()));

        if(iDataPack)

            delete iDataPack; iDataPack=NULL;

        iDataPack = PackPresenceInfoLC(*presInfo);

        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 );

    CPresenceBuddyInfoImp* buddypresenceInfo = CPresenceBuddyInfoImp::NewLC();

    TXIMPObjectPacker< CPresenceBuddyInfoImp >::UnPackL(*buddypresenceInfo, *iDataPack);

    err = TryWriteBuddyToCacheL(buddypresenceInfo);

    if(err==KErrNone) //ownership transferred    

        CleanupStack::Pop(buddypresenceInfo);

    else

        CleanupStack::PopAndDestroy(buddypresenceInfo);    

    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);

    CPresenceBuddyInfoListImp* buddyPresenceInfoList(NULL);

    CPresenceCacheBuddyStore* buddyStore(NULL);

    MPresenceBuddyInfo* presBuddyInfo(NULL);

    TInt presCount(0);

    TInt count(0);

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

        {

        serviceStore = iServer.iPresenceCache[i];

        if (serviceName->Des() == serviceStore->ServiceName())

            {

            presCount = serviceStore->PresenceCount();

            // if it has presences

            if(presCount)

                {

                buddyPresenceInfoList = CPresenceBuddyInfoListImp::NewLC(*serviceName);

                buddyPresenceInfoList->SetOwnObjects(EFalse);

                count = serviceStore->Count();

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

                    {

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

                    presBuddyInfo = buddyStore->PresenceBuddyInfo();

                    if(presBuddyInfo)

                        buddyPresenceInfoList->BlindAddL(presBuddyInfo);    

                    }

                }

            break;

            }

        }

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

    if(buddyPresenceInfoList) // if found

        {

        if(iDataPackAsync)

            delete iDataPackAsync; iDataPackAsync = NULL;

        iDataPackAsync = TXIMPObjectPacker< CPresenceBuddyInfoListImp>::PackL( *buddyPresenceInfoList);

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

        CleanupStack::PopAndDestroy(buddyPresenceInfoList);

        }

    CleanupStack::PopAndDestroy(serviceName);

    iAsyncReq = NRequest::ENoRequestMade;

    iMessage.Complete(size);

    }

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

// CPresenceCacheSession::TryWriteBuddyToCache()

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

//

TInt CPresenceCacheSession::TryWriteBuddyToCacheL(MPresenceBuddyInfo* aBuddyPresInfo)

    {

    if(!aBuddyPresInfo)

        return KErrArgument;

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

    TInt serviceCount = iServer.iPresenceCache.Count();

    CPresenceCacheBuddyStore* buddyStore(NULL);

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

        {

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

            {

            buddyStore = (iServer.iPresenceCache[i])->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);

        }

    if(buddyStore) //  inform to subscribers

        NotifyAllSubscribersL(buddyStore);

    return buddyStore ? KErrNone : KErrGeneral;

    }

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

// CPresenceCacheSession::HandleCancel()

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

//

void CPresenceCacheSession::HandleCancel(const RMessage2& aMessage )

    {

    if (iActiveHelper->IsActive())

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

    aMessage.Complete(KErrNotFound);

    }

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

// CPresenceCacheSession::HandleBuddyCountInAllServices()

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

//

void CPresenceCacheSession::HandleBuddyCountInAllServices(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::HandleBuddyCountInService()

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

//

void CPresenceCacheSession::HandleBuddyCountInService(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() == (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::HandleDeleteService()

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

//

void CPresenceCacheSession::HandleDeleteService(const RMessage2& aMessage )

    {

    TRACE( _L("CPresenceCacheSession::HandleDeleteService - 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=0; i<serviceCount; i++)

        {

        if (serviceName->Des() == (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::HandleDeleteService - end"));

    }

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

// CPresenceCacheSession::HandleDeletePresence()

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

//

void CPresenceCacheSession::HandleDeletePresence(const RMessage2& aMessage )

    {

    const TInt pckSize = aMessage.GetDesLengthL(0);

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

    TPtr8 paramPckPtr = idPack->Des();

    aMessage.ReadL( 0, paramPckPtr );

    TInt err(KErrNotFound);

    TInt buddyCount(NULL);

    CXIMPIdentityImp* identity = CXIMPIdentityImp::NewLC();

    TXIMPObjectPacker< CXIMPIdentityImp >::UnPackL(*identity, *idPack);

    TPtrC serviceName = GetServiceName(identity->Identity());