/*
* Copyright (c) 2005-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:  Encapsulated all sync operations
*
*/


#include "rsfwsyncoperations.h"
#include "rsfwrfemessagerequest.h"
#include "rsfwvolumetable.h"
#include "rsfwvolume.h"
#include "rsfwfileengine.h"
#include "rsfwfiletable.h"
#include "rsfwfileentry.h"
#include "rsfwrfesession.h"
#include "rsfwinterface.h"
#include "rsfwcontrol.h"
#include "mdebug.h"

   
// ----------------------------------------------------------------------------
// TRFeSynCRsfwRfeRequest::DoRequestL
// wrapper for all sync requests
// ----------------------------------------------------------------------------
// 
void TRFeSynCRsfwRfeRequest::DoRequestL(CRsfwRfeRequest* aRequest) 
    {
    CRsfwRfeMessageRequest* request = (CRsfwRfeMessageRequest*) aRequest;
    request->Session()->Volume()->DispatchL(request->iInArgs,
                                            request->iOutArgs);
    }

// ----------------------------------------------------------------------------
// TRFeDismountVolumeId::DoRequestL
// dismount a previously mounted volume by volume ID
// ----------------------------------------------------------------------------
//  
void TRFeDismountVolumeId::DoRequestL(CRsfwRfeRequest* aRequest)
    {
    DEBUGSTRING(("TRFeDismountVolumeId::DoRequestL"));
    CRsfwRfeMessageRequest* request = (CRsfwRfeMessageRequest*) aRequest;
    TInt volumeId = reinterpret_cast<TInt>(request->Message().Ptr0());
    DEBUGSTRING(("EDismount: volume %d", volumeId));
    request->Session()->Volume()->DismountByVolumeIdL(volumeId, ETrue);
    // This is called from the fileserver main thread.
    // Therefore, we should return quickly.
    }
    
// ----------------------------------------------------------------------------
// TRFeDismountByDriveLetter::DoRequestL
// dismount a previously mounted volume by drive letter
// ----------------------------------------------------------------------------
//   
void TRFeDismountByDriveLetter::DoRequestL(CRsfwRfeRequest* aRequest)
    {
    DEBUGSTRING(("TRFeDismountByDriveLetter::DoRequestL"));
    // Dismount a volume by drive letter
    // synchronous request
    CRsfwRfeMessageRequest* request = (CRsfwRfeMessageRequest*) aRequest;
    TChar driveLetter = reinterpret_cast<TInt>(request->Message().Ptr0());
    DEBUGSTRING(("EDismountByDriveLetter: '%c'", TUint(driveLetter)));
    request->Session()->Volume()->DismountByDriveLetterL(driveLetter, ETrue); 
    }


// ----------------------------------------------------------------------------
// TRFeGetMountList::DoRequestL
// get a list of currently active mounts
// ----------------------------------------------------------------------------
//      
void TRFeGetMountList::DoRequestL(CRsfwRfeRequest* aRequest)
    {
    DEBUGSTRING(("TRFeGetMountList::DoRequestL"));
    // synchronous request
    CRsfwRfeMessageRequest* request = (CRsfwRfeMessageRequest*) aRequest;
    TDriveList mountList;
    request->Session()->Volume()->GetMountList(mountList);
    TPckg<TDriveList> p(mountList);
    request->Message().WriteL(0, p);
    DEBUGSTRING8(("EGetMountList: '%S'", &mountList));
    }


// ----------------------------------------------------------------------------
// TRFeGetMountInfo::DoRequestL
// get information about a specific mount
// ----------------------------------------------------------------------------
//        
void TRFeGetMountInfo::DoRequestL(CRsfwRfeRequest* aRequest)
    {
    DEBUGSTRING(("TRFeGetMountInfo::DoRequestL"));
    // synchronous request
    CRsfwRfeMessageRequest* request = (CRsfwRfeMessageRequest*) aRequest;
    TRsfwMountInfo* mountInfo = new (ELeave) TRsfwMountInfo;
    CleanupStack::PushL(mountInfo);
    mountInfo->iMountConfig.iDriveLetter = 
        reinterpret_cast<TInt>(request->Message().Ptr0());
    TInt err = request->Session()->Volume()->GetMountInfo(*mountInfo);
    DEBUGSTRING(("EGetMountInfo for '%c' (err=%d)",
                 TUint(mountInfo->iMountConfig.iDriveLetter),
                 err));
    if (err != KErrNone)
        {
        mountInfo->iMountConfig.iUri.Zero();
        }
    TPckg<TRsfwMountInfo> mountInfoPackage(*mountInfo);
    request->Message().WriteL(1, mountInfoPackage);
    CleanupStack::PopAndDestroy(mountInfo);
    }  
    
    
// ----------------------------------------------------------------------------
// TRFeWriteData::DoRequestL
// get permission to write certain amount of data
// ----------------------------------------------------------------------------
//    
void TRFeWriteData::DoRequestL(CRsfwRfeRequest* aRequest) 
    {
    DEBUGSTRING(("TRFeWriteData::DoRequestL"));
    CRsfwRfeMessageRequest* request = (CRsfwRfeMessageRequest*) aRequest;
    TRfeWriteDataInArgs* inArgs =
        static_cast<TRfeWriteDataInArgs*>(request->iInArgs);
    TRfeWriteDataOutArgs* outArgs =
        static_cast<TRfeWriteDataOutArgs*>(request->iOutArgs);
    outArgs->iOkToWrite =
        request->iVolumeTable->EnsureCacheCanBeAddedL(inArgs->iBytes); 
        
    if (outArgs->iOkToWrite)  
        {
        // make sure "dirty bit" is on (file has uncommited modifications)
        CRsfwFileEntry* entry= 
            request->iVolume->iFileEngine->iFileTable->Lookup(inArgs->iFid);
        if (entry) 
            {
            entry->SetOpenedForWriting(ETrue);
            request->iVolume->iFileEngine->iFileTable->SaveMetaDataDelta();
            }
        // if writing has been cancelled, we have to inform the file server plugin
        if (entry->IsCancelled()) 
            {
            User::Leave(KErrCancel);
            }
        
        }
    }

void TRFeDirectoryRefresh::DoRequestL(CRsfwRfeRequest* aRequest) 
    {
    DEBUGSTRING(("TRFeDirectoryRefresh::DoRequestL"));
    CRsfwRfeMessageRequest* request = (CRsfwRfeMessageRequest*) aRequest;
    HBufC* refreshBuf = HBufC::NewLC(KMaxPath);
    TPtr refPtr = refreshBuf->Des();
    request->Message().ReadL(0, refPtr);
    User::LeaveIfError(request->Session()->Volume()->PurgeFromCache(refPtr));
    CleanupStack::PopAndDestroy(refreshBuf);
    }


void TRFeCancelAll::DoRequestL(CRsfwRfeRequest* aRequest)
    {
    DEBUGSTRING(("TRFeCancelAll::DoRequestL"));
    CRsfwRfeMessageRequest* request = (CRsfwRfeMessageRequest*) aRequest;
    HBufC* fileBuf = HBufC::NewLC(KMaxPath);
    TPtr filePtr = fileBuf->Des();
    request->Message().ReadL(0, filePtr);
    User::LeaveIfError(request->Session()->Volume()->CancelTransferL(filePtr));
    CleanupStack::PopAndDestroy(fileBuf);
    }