/*

* 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 the License "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:    Implements VoD download API*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <s32mem.h>

#include "IptvDebug.h"

#include "TIptvUint32StreamObject.h"

#include "CIptvMyVideosVideoBriefDetails.h"

#include "CIptvVodDlDownloadList.h"

#include "IptvClientServerCommon.h"

#include "CIptvVodDlClient.h"

#include "MIptvVodDlClientObserver.h"

#include "IptvServer.pan"

#include "CIptvVodDlDownloadReq.h"

#include "CIptvVodDlResumeDownloadReq.h"

#include "TIptvVodDlDownloadId.h"

#include "CIptvVodDlClient.h"

#include "CIptvVodDlDownloadEvent.h"

#include "CIptvVodDlCancelDownloadReq.h"

#include "CIptvEventListener.h"

// ============================ MEMBER FUNCTIONS ===============================

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

// CIptvVodDlClient::CIptvVodDlClient

// C++ default constructor can NOT contain any code, that

// might leave.

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

CIptvVodDlClient::CIptvVodDlClient( MIptvVodDlClientObserver& aClientObserver ) 

: CIptvClientBase(), iClientObserver( aClientObserver ), iIpcMsgPtr((unsigned char*)0, 0)

    {

    CActiveScheduler::Add( this );

    }

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

// CIptvVodDlClient::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CIptvVodDlClient::ConstructL()

    {

    iPendingReq = -1;

    iActiveSchedulerWait = new ( ELeave ) CActiveSchedulerWait();

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

    CIptvVodDlDownloadEvent* event = CIptvVodDlDownloadEvent::NewL();

    CleanupStack::PushL(event); // 1->

    iEventListener = CIptvEventListener::NewL( *this,

                                               event /* ownership moves */,

                                               EIptvEngineVodDlGetEventSizeReq,

                                               EIptvEngineVodDlGetEventData,

                                               EIptvEngineVodDlCancelGetEventSizeReq );

    CleanupStack::Pop(event); // <-1

    iReqQueue.Reset();

    }

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

// CIptvVodDlClient::NewL

// Two-phased constructor.

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

//

EXPORT_C CIptvVodDlClient* CIptvVodDlClient::NewL(MIptvVodDlClientObserver& aClientObserver)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient::NewL()");

    CIptvVodDlClient* self = new ( ELeave ) CIptvVodDlClient( aClientObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(self);

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient::NewL() exit");

    return self;

    }

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

// CIptvVodDlClient::NewLC

// Two-phased constructor.

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

//

EXPORT_C CIptvVodDlClient* CIptvVodDlClient::NewLC(MIptvVodDlClientObserver& aClientObserver)

    {

    CIptvVodDlClient* self = new ( ELeave ) CIptvVodDlClient( aClientObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor

EXPORT_C CIptvVodDlClient::~CIptvVodDlClient()

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient::~CIptvVodDlClient() start");

    if (IsActive())

        {

        IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient:: there is a message pending");

        if (iWaitForFlushInDestructor)

            {

            WaitForFlush();

            }

        else

            {

            IPTVLOGSTRING2_LOW_LEVEL("CIptvVodDlClient:: iWaitForFlushInDestructor was EFalse, discarding %d commands", iReqQueue.Count());

            Cancel();

            }

        }

    delete iEventListener;

    delete iIpcMsg;

    iReqQueue.Close();

    delete iActiveSchedulerWait;

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient::~CIptvVodDlClient exit");

    }

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

// CIptvVodDlClient::Purchase

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

EXPORT_C TInt CIptvVodDlClient::PurchaseL(TIptvServiceId /* aServiceId */,

                                          TIptvContentId /* aContentId */)

    {

    // 1) Create Ipc message function EIptvEngineVoDDlPurchaseReq with aServiceId and aContentId

    // 2) SendReceive message synchronously (request completed at server side)

    // 3) Return status to caller

    return KErrNone;

    }

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

// CIptvVodDlClient::DownloadL

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

EXPORT_C TIptvDlError CIptvVodDlClient::DownloadL(TUint32 aIapId,

                                                  TIptvServiceId aServiceId,

                                                  TIptvContentId aContentId,

                                                  TUint32 aIndex,                                                    

                                                  TIptvDownloadType aDlType)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient::DownloadL()");

    CIptvVodDlDownloadReq* dlReq;

    dlReq = CIptvVodDlDownloadReq::NewL();

    CleanupStack::PushL(dlReq); // 1->

    dlReq->iIapId     = aIapId;

    dlReq->iServiceId = aServiceId;

    dlReq->iContentId = aContentId;

    dlReq->iIndex     = aIndex;

    dlReq->iDlType    = aDlType;

    //allocate a new IPC message

    HBufC8* ipcMsg = HBufC8::NewL(dlReq->CountExternalizeSize());

    CleanupStack::PushL(ipcMsg); // 2->

    TPtr8 ipcMsgPtr(ipcMsg->Des());

    RDesWriteStream writeStream;

    writeStream.Open(ipcMsgPtr);

    writeStream.PushL(); // 3->        

    dlReq->ExternalizeL(writeStream); //write the download item to the stream

    writeStream.Close();

    writeStream.Pop(); // <-3

    //send download item as TPtr8 over IPC

    TInt globalError = iSession.SendRequest(EIptvEngineVodDlDownload, ipcMsgPtr);

    TIptvDlError result;

    if(globalError == KErrNone)

        {

        RDesReadStream readStream;

        readStream.Open(ipcMsgPtr);

        readStream.PushL(); // 2->

        result = static_cast<TIptvDlError>(readStream.ReadUint8L());

        readStream.Close();

        readStream.Pop(); // <-2

        }

    else

        {

        IPTVLOGSTRING2_LOW_LEVEL("CIptvVodDlClient:: dl request completed with error code: %d", globalError);

        IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient:: server side leaved?");

        result = EIptvDlGeneral;

        }

    CleanupStack::PopAndDestroy(ipcMsg); // <-2

    CleanupStack::PopAndDestroy(dlReq); // <-1

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient::DownloadL() exit");

    return result;

    }

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

// CIptvVodDlClient::DownloadReqL

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

EXPORT_C void CIptvVodDlClient::DownloadReqL( TUint32 aIapId,

                                              TIptvServiceId aServiceId,

                                              TIptvContentId aContentId,

                                              TUint32 aContentIndex,

                                              TIptvDownloadType aDlType )

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient::DownloadReqL()");

    CIptvVodDlDownloadReq* dlReq = CIptvVodDlDownloadReq::NewL();

    CleanupStack::PushL( dlReq ); // 1->

    dlReq->iIapId     = aIapId;

    dlReq->iServiceId = aServiceId;

    dlReq->iContentId = aContentId;

    dlReq->iIndex     = aContentIndex;

    dlReq->iDlType    = aDlType;

    if ( IsActive() )

        {

        IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient:: putting dl in queue");

        iReqQueue.AppendL(dlReq);

        CleanupStack::Pop(dlReq); // <-1

        }

    else

        {

        IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient:: sending immedetially");

        SendDownloadReqL( *dlReq );

        CleanupStack::PopAndDestroy( dlReq ); // <-1

        }

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient::DownloadReqL() exit");

    }

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

// CIptvVodDlClient::CancelDownloadL

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

EXPORT_C TInt CIptvVodDlClient::CancelDownloadL( CIptvMyVideosGlobalFileId& aGlobalFileId )

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient::CancelDownloadL()");

    TIptvVodDlDownloadId downloadId;

    downloadId.iServiceIdAndContentIdAreValid = EFalse;

    downloadId.iServiceId                     = 0;

    downloadId.iContentId                     = 0;

    downloadId.iFileIdAndDriveAreValid        = ETrue;

    downloadId.iFileId                        = aGlobalFileId.iFileId;

    downloadId.iDrive                         = aGlobalFileId.iDrive;

    //no need to check queue since the global file id is valid -> cant be in queue

    TInt resp = SendRequestL(static_cast<TUint16>(EIptvEngineVodDlCancelDownload), downloadId);

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient::CancelDownloadL()");

    return resp;

    }

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

// CIptvVodDlClient::CancelDownloadL

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

EXPORT_C TInt CIptvVodDlClient::CancelDownloadL(TUint32 aServiceId, TUint32 aContentId)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient::CancelDownloadL()");

    TIptvVodDlDownloadId downloadId;

    downloadId.iServiceIdAndContentIdAreValid = ETrue;

    downloadId.iServiceId                     = aServiceId;

    downloadId.iContentId                     = aContentId;

    downloadId.iFileIdAndDriveAreValid        = EFalse;

    downloadId.iFileId                        = 0;

    downloadId.iDrive                         = 0;

    TBool removed = CancelDlFromQueueL(downloadId.iServiceId, downloadId.iContentId, EFalse /* dont send event */);

    if (removed)

        {            

        IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient:: dl cancelled from queue");

        return KErrNone;

        }

    TInt resp = SendRequestL(static_cast<TUint16>(EIptvEngineVodDlCancelDownload), downloadId);

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient::CancelDownloadL()");

    return resp;

    }

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

// CIptvVodDlClient::CancelDownloadReqL

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

EXPORT_C void CIptvVodDlClient::CancelDownloadReqL(TIptvVodDlDownloadId& aDownloadId)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient::CancelDownloadReqL(aDownloadId) start");

    if (aDownloadId.iServiceIdAndContentIdAreValid == EFalse && 

        aDownloadId.iFileIdAndDriveAreValid == EFalse)

        {

        User::Leave(KErrArgument);

        }

    //can be in queue only if iServiceIdAndContentIdAreValid is valid.

    //Cant be in queue if global file id is valid

    if (aDownloadId.iServiceIdAndContentIdAreValid)

        {

        TBool removed = CancelDlFromQueueL(aDownloadId.iServiceId, aDownloadId.iContentId, ETrue /* send event */);

        if (removed)

            {            

            IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient:: dl cancelled from queue");

            return;

            }

        }

    CIptvVodDlCancelDownloadReq* cancelDlReq = CIptvVodDlCancelDownloadReq::NewL();

    CleanupStack::PushL(cancelDlReq); // 1->

    cancelDlReq->Set(aDownloadId);

    if (IsActive())

        {

        IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient:: active -> putting CancelDlReq in queue");

        iReqQueue.AppendL(cancelDlReq);

        CleanupStack::Pop(cancelDlReq); // <-1

        }

    else

        {

        IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient:: sending cancel dl req immedetially");

        SendCancelDownloadReqL(*cancelDlReq);

        CleanupStack::PopAndDestroy(cancelDlReq); // <-1

        }

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient::CancelDownloadReqL(aDownloadId) exit");

    }

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

// CIptvVodDlClient::PauseDownload

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

EXPORT_C TInt CIptvVodDlClient::PauseDownloadL(CIptvMyVideosGlobalFileId& aGlobalFileId)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient::PauseDownloadL()");

    //send download item as TPtr8 over IPC

    TInt result = SendRequestL(static_cast<TUint16>(EIptvEngineVodDlPauseDownload),

                               aGlobalFileId);

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient::PauseDownloadL() exit");

    return result;

    }

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

// CIptvVodDlClient::PauseAllDownloads

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

EXPORT_C TInt CIptvVodDlClient::PauseAllDownloads()

    {

    return iSession.SendRequest(static_cast<TUint16>(EIptvEngineVodDlPauseAllDownloads));

    }

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

// CIptvVodDlClient::ResumeDownload

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

EXPORT_C TInt CIptvVodDlClient::ResumeDownloadL(CIptvMyVideosGlobalFileId& aGlobalFileId,

                                                TBool aUseUserNameAndPassword,

                                                const TDesC& aUserName,

                                                const TDesC& aPassword,

                                                TUint32 aIapId,

                                                TBool aUseIapId)

    {

    if(aUserName.Length() > KIptvVodDlUserNameMaxLength)

        {

        IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient:: User name too long");

        return KErrArgument;        

        }

    if(aPassword.Length() > KIptvVodDlPasswordMaxLength)

        {

        IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient:: Password too long");

        return KErrArgument;

        }

    CIptvVodDlResumeDownloadReq* resumeDownloadReq = CIptvVodDlResumeDownloadReq::NewL();

    CleanupStack::PushL(resumeDownloadReq); // 1->

    resumeDownloadReq->iDownloadId.iFileIdAndDriveAreValid        = ETrue;

    resumeDownloadReq->iDownloadId.iFileId                        = aGlobalFileId.iFileId;

    resumeDownloadReq->iDownloadId.iDrive                         = aGlobalFileId.iDrive;

    resumeDownloadReq->iDownloadId.iServiceIdAndContentIdAreValid = EFalse;

    resumeDownloadReq->iUseUserNameAndPassword                    = aUseUserNameAndPassword;

    resumeDownloadReq->iUserName                                  = aUserName;

    resumeDownloadReq->iPassword                                  = aPassword;

    resumeDownloadReq->iIapId                                     = aIapId;

    resumeDownloadReq->iUseIapId                                  = aUseIapId;

    TInt resp = SendRequestL(static_cast<TUint16>(EIptvEngineVodDlResumeDownload), *resumeDownloadReq);

    CleanupStack::PopAndDestroy(resumeDownloadReq); // <-1

    return resp;    

    }

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

// CIptvVodDlClient::ResumeDownload

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

EXPORT_C TInt CIptvVodDlClient::ResumeDownloadL(TUint32 aServiceId,

                                                TUint32 aContentId,

                                                TBool aUseUserNameAndPassword,

                                                const TDesC& aUserName,

                                                const TDesC& aPassword,

                                                TUint32 aIapId,

                                                TBool aUseIapId)

    {

    if(aUserName.Length() > KIptvVodDlUserNameMaxLength)

        {

        IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient:: User name too long");

        return KErrArgument;        

        }

    if(aPassword.Length() > KIptvVodDlPasswordMaxLength)

        {

        IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient:: Password too long");

        return KErrArgument;

        }

    CIptvVodDlResumeDownloadReq* resumeDownloadReq = CIptvVodDlResumeDownloadReq::NewL();

    CleanupStack::PushL(resumeDownloadReq); // 1->

    resumeDownloadReq->iDownloadId.iFileIdAndDriveAreValid        = EFalse;

    resumeDownloadReq->iDownloadId.iServiceIdAndContentIdAreValid = ETrue;

    resumeDownloadReq->iDownloadId.iServiceId                     = aServiceId;

    resumeDownloadReq->iDownloadId.iContentId                     = aContentId;

    resumeDownloadReq->iUseUserNameAndPassword                    = aUseUserNameAndPassword;

    resumeDownloadReq->iUserName                                  = aUserName;

    resumeDownloadReq->iPassword                                  = aPassword;

    resumeDownloadReq->iIapId                                     = aIapId;

    resumeDownloadReq->iUseIapId                                  = aUseIapId;

    TInt resp = SendRequestL(static_cast<TUint16>(EIptvEngineVodDlResumeDownload), *resumeDownloadReq);

    CleanupStack::PopAndDestroy(resumeDownloadReq); // <-1

    return resp;    

    }

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

// CIptvVodDlClient::ResumeAllDownloads

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

EXPORT_C TInt CIptvVodDlClient::ResumeAllDownloads()

    {    

    return iSession.SendRequest(static_cast<TUint16>(EIptvEngineVodDlResumeAllDownloads));

    }

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

// CIptvVodDlClient::GetDownloadList

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

EXPORT_C TInt CIptvVodDlClient::GetDownloadListL(CIptvVodDlDownloadList& aDownloadList)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient::GetDownloadListL()");

    TIptvUint32StreamObject sizeObj;

    TInt globalError = SendRequestL(static_cast<TUint16>(EIptvEngineVodDlGetDownloadListSize),

                       sizeObj,

                       sizeObj.CountExternalizeSize() /* = 4 */);

    if(globalError == KErrNone)

        {

        if(sizeObj.iData > 0)

            {

            globalError = SendRequestL(static_cast<TUint16>(EIptvEngineVodDlGetDownloadList),

                                       aDownloadList,

                                       sizeObj.iData);

            }

        else

            {

            IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient:: download list was empty");

            globalError = KErrNotFound;            

            }

        }

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodDlClient::GetDownloadListL() exit");

    return globalError;

    }

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

// CIptvVodDlClient::GetDownloadProgress

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

EXPORT_C TInt CIptvVodDlClient::GetDownloadProgressL(CIptvMyVideosGlobalFileId& aGlobalFileId)

    {

    // 1) Create Ipc message function EIptvEngineVoDDlGetDownloadProgressReq with aGlobalFileId

    // 2) SendReceive message synchronously

    // 3) Return progress and status to caller

    TIptvUint32StreamObject progress;

    TInt result = SendRequestL(static_cast<TUint16>(EIptvEngineVodDlGetDownloadProgressReq),

                               aGlobalFileId,

                               progress,

                               0);

    if(result != KErrNone)

        {

        return result;

        }

    else 

        {   

        return static_cast<TInt>(progress.iData);

        }

    }

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

// Updates existing soft notification.

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

//

EXPORT_C void CIptvVodDlClient::UpdateDownloadNotification(

    const TDesC& aMsg )