/*

* 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:  Implementation of FileSource.

*  Version     : %version: bh1mmcf#5.1.7 %

*

*/

#include <f32file.h>

#include <e32std.h>

#include <mmfdatabuffer.h>

#include <mmfutilities.h>

#include <mmf/common/mmfcontroller.h>

#include <mmfpaniccodes.h>

#include "FileMultimediaSource.h"

#include "FileDataSource.h"

#include "MmffilePriv.h"

#include "FileAccess.h"

#include "SinkQueueItem.h"

#include "FileDataSourceCommon.h"

#include <MultimediaDataSourceEvents.h>

#include "FileSourceUid.h"

#ifdef _DEBUG

#define DEBPRN1(str)        RDebug::Print(str);

#define DEBPRN2(str, val1)   RDebug::Print(str, val1);

#define DEBPRN3(str, val1, val2)   RDebug::Print(str, val1, val2);

#define DEBPRN4(str, val1, val2, val3)   RDebug::Print(str, val1, val2, val3);

#define DEBPRN5(str, val1, val2, val3, val4)   RDebug::Print(str, val1, val2, val3, val4);

#else

#define DEBPRN1(str)

#define DEBPRN2(str, val1)

#define DEBPRN3(str, val1, val2)

#define DEBPRN4(str, val1, val2, val3)

#define DEBPRN5(str, val1, val2, val3, val4)

#endif // _DEBUG

void Panic(TMMFFilePanicCode aPanicCode)

    {

    _LIT(KMMFFilePanicCategory, "MMFFile");

    User::Panic(KMMFFilePanicCategory, aPanicCode);

    }

/**

* Constructs a CTransferBufferCopy

*

* @return CTransferBufferCopy*

*/

CTransferBufferCopy* CTransferBufferCopy::NewL(TInt aMaxLength)

    {

    CTransferBufferCopy* self = new (ELeave) CTransferBufferCopy(aMaxLength);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

/**

* Second phase constructor for CTransferBufferCopy

*

* @return void

*/

void CTransferBufferCopy::ConstructL()

    {

    iBuffer = static_cast<TUint8*>(User::AllocL(iMaxLength));

    iBufferDes.Set(iBuffer,0,iMaxLength);

    }

CFileSource* CFileSource::NewL(TUid aType )

    {

    DEBPRN1(_L("CFileSource::NewL"));

    CFileSource* self = new (ELeave) CFileSource(aType);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CFileSource::CFileSource(TUid aType)

: MDataSource(aType)

    {

    iInitData = NULL;

    }

CFileSource::~CFileSource(void)

    {

    delete iInitData;

    iInitData = NULL;        

    }

void CFileSource::ConstructL (void)

    {

    }

// From MDataSource begins

TUid CFileSource::DataSourceType() const

    {

    return KMmfFileSource;

    }

TFourCC CFileSource::SourceDataTypeCode(TMediaId /*aMediaId*/ )

    {

    TFourCC fourCC;        

    return iMultiMediaSource->GetDataTypeCode(fourCC);

    }

TInt CFileSource::SetSourceDataTypeCode(TFourCC aSourceFourCC,

                                                  TMediaId /*aMediaId*/ )

    {

    iMultiMediaSource->SetDataTypeCode(aSourceFourCC);

    return KErrNone;

    }

void CFileSource::FillBufferL(CMMFBuffer* aBuffer,

                                        MDataSink* aConsumer,

                                        TMediaId /*aMediaId*/ )

    {

    // Requires that iFile is open for read.

    // Reads data from iFile into aBuffer

    //TInt status(KErrNone);

    if ((!aConsumer) || (!aBuffer))

        User::Leave(KErrArgument);

    iMultiMediaSource->AppendBufferToSinkQueue(aBuffer,NULL,aConsumer,EFalse);

    iMultiMediaSource->ServiceFillBuffer();

    }

void CFileSource::BufferEmptiedL(CMMFBuffer* /*aBuffer*/ )

    {

    User::Leave(KErrUnknown);

    }

TBool CFileSource::CanCreateSourceBuffer()

    {

    return EFalse;

    }

CMMFBuffer* CFileSource::CreateSourceBufferL(TMediaId /*aMediaId*/,

                                                       TBool &/*aReference*/ )

    {

    return NULL;

    }

TInt CFileSource::SourceThreadLogon( MAsyncEventHandler& /*aEventHandler*/ )

    {

    return iMultiMediaSource->Open();

    }

void CFileSource::SourceThreadLogoff()

    {

    iMultiMediaSource->Close();

    }

void CFileSource::SourcePrimeL()

    {

    DEBPRN1(_L("CFileSource::SourcePrimeL"));

    User::LeaveIfError(iMultiMediaSource->Prime());

    }

void CFileSource::SourcePlayL()

    {

    DEBPRN1(_L("CFileSource::SourcePlayL"));

    User::LeaveIfError(iMultiMediaSource->Play());

    }

void CFileSource::SourceStopL()

    {

    DEBPRN1(_L("CFileSource::SourceStopL"));

    User::LeaveIfError(iMultiMediaSource->Stop());

    }

void CFileSource::ConstructSourceL(const TDesC8& aInitData )

    {

    if(iInitData)

        {

        delete iInitData;

        iInitData = NULL;        

        }

    iInitData = aInitData.AllocL();        

    }

void CFileSource::SourceCustomCommand(TMMFMessage& aMessage)

    {

    iMultiMediaSource->SourceCustomCommand(aMessage);        

    }

void CFileSource::SetMultimediaSource(CFileMultimediaSource& aMultimediaSource)

    {

    iMultiMediaSource = &aMultimediaSource;   

    }

TDesC8& CFileSource::GetInitData()

    {

    return *iInitData;    

    }

EXPORT_C CFileMultimediaSource* CFileMultimediaSource::NewL(MDataSource& aDataSource)

    {

    DEBPRN1(_L("CFileMultimediaSource::NewL"));

    CFileMultimediaSource* self = new (ELeave) CFileMultimediaSource(aDataSource);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

/**

Destructor.

*/

CFileMultimediaSource::~CFileMultimediaSource() 

    {

    DEBPRN1(_L("CFileMultimediaSource::~CFileMultimediaSource() "));    

    delete iInitData;

    delete iFile;

    EmptySinkQueue();

    iHandle.Close();

    iFsSession.Close();

    delete iFileName;

    delete iFileExt;

    delete iFilePath;

    delete iFileDrive;

    delete iCAFParameters;

    delete iSinkQueue;

    if(iMessage)

        {

        if(!iMessage->IsCompleted())

            {

            iMessage->Complete(KErrDied);

            delete iMessage;

            iMessage = NULL;

            }

        }

    // Get rid of everything in RArray's & close them.

    iRequests.ResetAndDestroy();

    iTransferBufferCopies.ResetAndDestroy();

    DEBPRN1(_L("CFileMultimediaSource::~CFileMultimediaSource() exit"));   

    }

/**

Protected constructor.

The default implementation is empty.

*/

CFileMultimediaSource::CFileMultimediaSource(

                                       MDataSource& aDataSource )

                                       : iSnkItemsCount(0),

                                       iSnkBytes(0),

                                       iDownloadSize(0),

                                       iTransferRate(0),

                                       //iConsumer(NULL),

                                       iBufferedDataSize(0),

                                       iDLFileSize(0),

                                       isDownloadComplete(EFalse),

                                       iFileSize(0),

                                       iParentDataSource(&aDataSource)

    {

    iMessage = NULL;

    iFile = NULL;

    iState = ECLOSED;

    iObserver = NULL;    

    iInitData = NULL;

    }

/**

Constructs an CFileMultimediaSource MDataSource.

@return A pointer to the new CFileMultimediaSource data source.

*/

/*MDataSource* CFileMultimediaSource::NewSourceL() 

    {

    CFileMultimediaSource* self = new (ELeave) CFileMultimediaSource( KMmfFileSource ) ;

    return STATIC_CAST( MDataSource*, self ) ;

    }*/

/**

Perform source construction dependant on the source construction

initialisation data aInitData.

@param  aInitData

The TPckg<TMMFFileParams> descriptor package containing the file name and full path.

*/

void CFileMultimediaSource::ConstructL()

    {

    CFileSource* fileSource = static_cast<CFileSource*>(iParentDataSource);    

    iInitData = (fileSource->GetInitData()).AllocL();

    fileSource->SetMultimediaSource(*this);

    ConstructL(*iInitData, ESourceMode);

    iSinkQueue = new(ELeave) TSglQue<CSinkQueueItem>(_FOFF(CSinkQueueItem, iLink));

    }

/**

Protected constructor.

Extracts the initialisation data provided by the calling functions: ConstructSourceL() and 

ConstructSinkL(). Creates a file server session and sets up file name. If there is a file name and 

it cannot be found this function leaves. If there is no file name the function leaves. Does not 

attempt to open the file or check whether the file exists.

If aInitData contains a TMMFFileHandleParams instead of TMMFFileParams, the source/sink is constructed from 

the file handle provided by the caller

@param  aInitData

Initialisation data packaged in a TMMFFileParams or in a TMMFFileHandleParams (File Handle)

*/

void CFileMultimediaSource::ConstructL(const TDesC8& aInitData,TMMFileMode aFileMode)

    {

    User::LeaveIfError(iFsSession.Connect());

    // on IPCv2 we auto attach

    User::LeaveIfError(iFsSession.ShareAuto());

    User::LeaveIfError(iFsSession.ShareProtected());

    TBool fileInit = EFalse;

    HBufC* filename = NULL; 

    TBool filenamePushed = EFalse;

    iCAFParameters = new (ELeave) CCAFParameters;

    TBool drmContent = EFalse;

    RDesReadStream stream(aInitData);

    CleanupClosePushL(stream);

    TUid initUid;

    initUid = TUid::Uid(stream.ReadInt32L());

    if (initUid == KMMFileHandleSourceUid)

        {

        TPckgBuf<RFile*> fileptr;

        stream.ReadL(fileptr);

        iHandle.Duplicate(*fileptr());

        TInt length;

        length = stream.ReadInt32L();

        if (length>0)

            {

            iCAFParameters->iUniqueId = HBufC::NewL(length);

            TPtr16 ptr = iCAFParameters->iUniqueId->Des();

            stream.ReadL(ptr, length);

            }

        iFileHandle = ETrue;

        filename = HBufC::NewMaxL(KMaxFileName);

        TPtr ptr = filename->Des();

        iHandle.Name(ptr);

        fileInit = ETrue;

        drmContent = ETrue;

        iCAFParameters->iEnableUI = stream.ReadInt32L();

        }

    else if (initUid == KMMFileSourceUid)

        {

        TInt length;

        length = stream.ReadInt32L();

        filename = HBufC::NewMaxLC(length);

        TPtr ptr = filename->Des();

        stream.ReadL(ptr, length);

        length = stream.ReadInt32L();

        if (length>0)

            {

            iCAFParameters->iUniqueId = HBufC::NewMaxL(length);

            ptr.Set(iCAFParameters->iUniqueId->Des());

            stream.ReadL(ptr, length);

            }

        CleanupStack::Pop(filename);

        fileInit = ETrue;

        drmContent = ETrue;

        iFileHandle = EFalse; 

        iCAFParameters->iEnableUI = stream.ReadInt32L();

        }

    else

        {

        //		TODO If the UID is unknown we should reject, but  currently

        //		code also used for older calls that just supply filename.

        //		User::Leave(KErrNotSupported);

        }

    CleanupStack::PopAndDestroy(&stream);

    if (!fileInit && aInitData.Length() == sizeof(TMMFFileHandleParams))

        {

        TMMFFileHandleParams params;

        TPckgC<TMMFFileHandleParams> config(params);

        config.Set(aInitData);

        params = config();

        if (params.iUid == KFileHandleUid)

            {

            fileInit = ETrue;

            User::LeaveIfError(iHandle.Duplicate(*params.iFile));

            TInt pos = 0;

            // make sure the duplicate handle is at the start of the file - the usage of the file handle really requires this

            User::LeaveIfError(iHandle.Seek(ESeekStart, pos));

            iFileHandle = ETrue;

            filename = HBufC::NewMaxLC(KMaxFileName);

            filenamePushed = ETrue;

            TPtr ptr = filename->Des();

            User::LeaveIfError(iHandle.Name(ptr));

            }

        }

    if (!fileInit) // do old case as last resort

        {

        TMMFFileParams params;

        TPckgC<TMMFFileParams> config(params);

        config.Set(aInitData);

        params = config();

        filename = params.iPath.AllocL();

        fileInit = ETrue;

        }

    if (!filenamePushed)

        {

        // from now on it is assumed pushed.

        CleanupStack::PushL(filename);

        }

    TParse parser ;

    User::LeaveIfError(parser.Set(*filename, NULL, NULL));

    CleanupStack::PopAndDestroy(filename);

    if ( !( parser.NamePresent() ) && !( parser.ExtPresent() ) )

        User::Leave( KErrBadName ) ;

    iFullFileName.Copy( parser.FullName() ) ;	

    iFileName = parser.Name().AllocL() ;

    iFileExt = parser.Ext().AllocL() ;

    iFilePath = parser.Path().AllocL() ;

    iFileDrive = parser.Drive().AllocL() ;

    // in order to simulate old behaviour we are not passing error out

    // but will try to create Content again during PrimeL()

    if (fileInit && drmContent && aFileMode==ESourceMode)

        {

        TInt contentError;

        if (iFileHandle)

            {

            TRAP(contentError, 

                iFile = CContentFile::NewL(iHandle, UniqueId(), iCAFParameters->iEnableUI);

            );

            }

        else

            {

            // Open for read-only access

            TRAP(contentError,

                iFile = CContentFile::NewL(iFsSession, iFullFileName, UniqueId(), EFileShareAny, iCAFParameters->iEnableUI);

            );

            }

        }

    }

/**

@deprecated

Returns an RFile handle to the current file.

If there is no current file, one is created. If the file exists then it is opened with read access 

if it is read only, write access otherwise. If the file does not exist then it is opened with

write access.

@leave KErrNotReady

The file is not open.

@return A handle to the current file.

*/

RFile& CFileMultimediaSource::FileL()

    {

    if (!iFile)

        User::Leave(KErrNotReady);

    if (iFileHandle)

        return iHandle;

    else

        return iFile->FileL();

    }

/** 

Returns the file name of the current file.

Note: This will give the wrong answer if the file is renamed!

@return The FileName (without extension).

*/

const TDesC& CFileMultimediaSource::FileName() const

    {

    return *iFileName ;

    }

/**

Returns the extension of the current file.

Note: This will give the wrong answer if the file is renamed!

@return The File Extension.

*/

const TDesC& CFileMultimediaSource::Extension() const 

    {