// Copyright (c) 2009 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:
//

/**
 @file
 @internalTechnology
*/

#include "cmediasyncserversession.h"
#include "cmediasyncserver.h"
#include "cmediasyncdatabase.h"
#include "cmediasyncobserver.h"
#include "cmediasyncdatawriter.h"

__FLOG_STMT(_LIT8(KComponent,"MediaSyncServerSession");)

const TInt KDefGlobalSharedHeapSize = 64 * 1024;//64K byte memory
const TInt KReduceFactor  = 2; 
const TInt KMaxRetryTimes = 3; 

CMediaSyncServerSession::CMediaSyncServerSession(CMediaSyncServer* aServer) : 
    iServer(aServer),
    iAllocated(EFalse)
    {
    __FLOG_OPEN(KMSSSubsystem, KComponent);
    __FLOG(_L8("CMediaSyncServerSession::CMediaSyncServerSession - Entry"));
    __FLOG(_L8("CMediaSyncServerSession::CMediaSyncServerSession - Exit"));    
    }
    
/**
Destructor.
*/
CMediaSyncServerSession::~CMediaSyncServerSession()
    {
    __FLOG(_L8("CMediaSyncServerSession::~CMediaSyncServerSession - Entry"));
    
    if (iAllocated)
        {
        iGlobalSharedHeap.Close();
        }
    
    __FLOG(_L8("CMediaSyncServerSession::~CMediaSyncServerSession - Exit"));
    __FLOG_CLOSE;    
    }

// --------------------------------------------------------------------------
// 
// From CSession2, passes the request forward to DispatchMessageL.
// --------------------------------------------------------------------------
//
void CMediaSyncServerSession::ServiceL(const RMessage2& aMessage)
    {
    __FLOG_VA((_L8("CMediaSyncServerSession::ServiceL - Function: %d"), aMessage.Function()));
    
    DispatchMessageL(aMessage);
    }

void CMediaSyncServerSession::DispatchMessageL(const RMessage2& aMessage)
    {
    __FLOG(_L8("CMediaSyncServerSession::DispatchMessageL - Entry"));
       
    switch( aMessage.Function() )
        {
        case EMediaSyncClientGetGSHHandle:
            {
            AllocateGlobalSharedHeapL(aMessage);            
            aMessage.Complete(iGlobalSharedHeap);
            }
            break;
            
        case EMediaSyncClientGetChanges:
            aMessage.Complete(GetChangesL(aMessage));
            break;
            
        case EMediaSyncClientRemoveAllRecords:
            {
            iServer->MediaSyncDatabase()->RemoveAllNotificationsL();
            iGlobalSharedHeap.Close();
            iAllocated = EFalse;
            aMessage.Complete(KErrNone);
            }
            break;
            
        case EMediaSyncClientEnableMonitor:
            iServer->MediaSyncObserver()->SubscribeForChangeNotificationL();
            aMessage.Complete(KErrNone);
            break;
            
        case EMediaSyncClientDisableMonitor:
            iServer->MediaSyncObserver()->UnsubscribeForChangeNotificationL();
            aMessage.Complete(KErrNone);
            break;
            
        case EMediaSyncClientNeedFullSync:
            aMessage.Complete(GetFullSyncFlag(aMessage));
            break;
            
        case EMediaSyncClientClearFullSync:
            iServer->ClearFullSyncFlag();
            aMessage.Complete(KErrNone);
            break;
            
        case EMediaSyncClientShutdown:
            CActiveScheduler::Stop();
            aMessage.Complete(KErrNone);
            break;
            
        default:
            aMessage.Panic(KMediaSyncClientPanicCategory, EBadRequest);
            break;
        }

    __FLOG(_L8("CMediaSyncServerSession::DispatchMessageL - Exit"));
    }

void CMediaSyncServerSession::AllocateGlobalSharedHeapL(const RMessage2& aMessage)
    {
    __FLOG(_L8("CMediaSyncServerSession::AllocateGlobalSharedHeapL - Entry"));
    
    if (!iAllocated)
        {
        TInt attemptedSize = aMessage.Int0();
        if (attemptedSize > KDefGlobalSharedHeapSize || attemptedSize <= 0)
            {
            attemptedSize = KDefGlobalSharedHeapSize;
            }
        
        TInt retryCount = KMaxRetryTimes;
        TInt redFactor = KReduceFactor;    
        TInt result = KErrNone;
        
        for (; retryCount > 0; retryCount--)
            {
            result = iGlobalSharedHeap.CreateGlobal(KNullDesC, attemptedSize, attemptedSize);
            
            if (result == KErrNone)
                {
                // We have succesfully allocated a GSH
                break;
                }
            else
                {
                // Reduce the size of the GSH by a scale factor
                attemptedSize = attemptedSize / redFactor;
                }
            }
            
        User::LeaveIfError(result); 
        iAllocated = ETrue;
        }
    
    __FLOG(_L8("CMediaSyncServerSession::AllocateGlobalSharedHeapL - Exit"));
    }

TInt CMediaSyncServerSession::GetChangesL(const RMessage2& aMessage)
    {
    __FLOG(_L8("CMediaSyncServerSession::GetChangesL - Entry"));

    TInt maxFetchCount = aMessage.Int0();
    CMediaSyncDataWriter* writer = CMediaSyncDataWriter::NewLC(iGlobalSharedHeap);
    TBool finished = EFalse;
    
    iServer->MediaSyncDatabase()->FetchNotificationsL(*writer, maxFetchCount, finished);
    TPtr8 finishPtr((TUint8*)&finished, sizeof(TBool), sizeof(TBool));
    
    aMessage.Write(1, finishPtr);
    
    CleanupStack::PopAndDestroy(writer);        
    
    __FLOG(_L8("CMediaSyncServerSession::GetChangesL - Exit"));
    
    return KErrNone;
    }

TInt CMediaSyncServerSession::GetFullSyncFlag(const RMessage2& aMessage)
    {
    __FLOG(_L8("CMediaSyncServerSession::GetFullSyncFlagL - Entry"));
        
    TBool needFullSync = iServer->NeedFullSync();
    TPtr8 finishPtr((TUint8*)&needFullSync, sizeof(TBool), sizeof(TBool)); 
    aMessage.Write(0, finishPtr);    
    
    __FLOG(_L8("CMediaSyncServerSession::GetFullSyncFlagL - Exit"));
    
    return KErrNone;
    }