/*

* 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:  rohandler wrapper for Download manager

 *

*/

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <es_enum_partner.h>

#endif

#include <centralrepository.h>

#include <cdblen.h>

#include <cmconnectionmethod.h>

#include <cmdestination.h>

#include <cmconnectionmethoddef.h>

#include <cmmanager.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif

#include <data_caging_path_literals.hrh>

#include <DownloadMgrClient.h>

#include <es_enum.h> // tconnectioninfo

#include <es_sock.h> // rconnection rsocket

#include <RoapEng.h>

#include <RoapDef.h>

#include <RoapObserver.h>

#include "RoapSyncWrapper.h"

#include "rohandlerdmgrwrapper.h"

#ifdef _DEBUG

#define DRMDEBUG( a ) RDebug::Print( a )

#define DRMDEBUG2( a, b ) RDebug::Print( a, b )

#define DRMDEBUG3( a, b, c ) RDebug::Print( a, b, c )

#define DRMDEBUGMETHOD( a ) RDebug::Print( \

    RoHdlrDMgrWrDebugLiterals::KMethodFormat(), &( a ) )

// #define DRMDEBUGMETHODSTART( a ) RDebug::Print( \

// RoHdlrDMgrWrDebugLiterals::KMethodStartFormat(), &( a ) )

// #define DRMDEBUGMETHODFINISH( a ) RDebug::Print( \

// RoHdlrDMgrWrDebugLiterals::KMethodFinishFormat(), &( a ) )

// #define LOG( a ) RFileLogger::Write( \

// KRoLogDir(), KRoLogFile(), EFileLoggingModeAppend, a );

// #define LOGHEX( ptr, len ) RFileLogger::HexDump( \

//  KRoLogDir(), KRoLogFile(), EFileLoggingModeAppend, \

//  _S( "" ), _S( "" ), ptr, len );

// #define LOG2( a, b ) RFileLogger::WriteFormat( \

// KRoLogDir(), KRoLogFile(), EFileLoggingModeAppend, a, b );

namespace RoHdlrDMgrWrDebugLiterals

    {

    // Uncomment following literals if using macros LOG, LOG2 or LOGHEX anywhere

    //    _LIT( KRoLogDir, "DRM" );

    //    _LIT( KRoLogFile, "RoHdlDmgrWrapper.log" );

    // method Formatters ( used in macros DRMDEBUGMETHOD )

    _LIT( KMethodFormat, "CRoHandlerDMgrWrapper::%S" );

    // method Formatters ( used in macro DRMDEBUGMETHODSTART )

    //    _LIT( KMethodStartFormat, "CRoHandlerDMgrWrapper::%S -->" );

    // method Formatters ( used in macro DRMDEBUGMETHODFINISH )

    //    _LIT( KMethodFinishFormat, "--> CRoHandlerDMgrWrapper::%S" );

    _LIT( KFormatMembValInt, "%S = %d" );

    //Constructors, destructor

    _LIT( KMethDestructor, "~CRoHandlerDMgrWrapper" );

    //Methods

    _LIT( KMethConstructL, "ConstructL" );

    _LIT( KMethNewL, "NewL" );

    _LIT( KMethNewLC, "NewLC" );

    _LIT( KMethDoDownloadAndHandleRoapTriggerL,

        "DoDownloadAndHandleRoapTriggerL" );

    _LIT( KFormatDoDlHdlRoapTrigL, "DoDownloadAndHandleRoapTriggerL: %S" );

    _LIT( KStrDlCreated, "download created" );

    _LIT( KStrDlFinished, "download finished" );

    _LIT( KMethSetDefaultAccessPointL, "SetDefaultAccessPointL" );

    _LIT( KMethHandleDMgrEventL, "HandleDMgrEventL" );

    _LIT( KFormatMethHandleDMgrEventL, "HandleDMgrEventL %S" );

    _LIT( KStrEHttpDlCreated, "EHttpDlCreated" );

    _LIT( KStrEHttpContentTypeReceived, "EHttpContentTypeReceived" );

    _LIT( KStrEHttpProgDisconnected, "EHttpProgDisconnected" );

    _LIT( KStrEHttpDlInprogress, "EHttpDlInprogress" );

    _LIT( KStrEHttpDlCompleted, "EHttpDlCompleted" );

    _LIT( KStrEHttpDlFailed, "EHttpDlFailed" );

    _LIT( KStrEConnectionFailed, "EConnectionFailed" );

    _LIT( KFormatEDlAttrErrorId, "EDlAttrErrorId = %d" );

    _LIT( KMiDownLoadState, "iDownLoadState" );

    _LIT( KMiProgressState, "iProgressState" );

    }

#else

#define DRMDEBUG( a )

#define DRMDEBUG2( a, b )

#define DRMDEBUG3( a, b, c )

#define DRMDEBUGMETHOD( a )

//#define DRMDEBUGMETHODSTART( a )

//#define DRMDEBUGMETHODFINISH( a )

//#define LOG( a )

//#define LOGHEX( ptr, len )

//#define LOG2( a, b )

#endif

// CONSTANTS

#ifndef RD_MULTIPLE_DRIVE

_LIT( KHelperTriggerFilePath, "d:\\" );

#endif

// ============================== LOCAL FUNCTIONS ==============================

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

// DeleteHttpDowload

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

//

LOCAL_C void DeleteHttpDowload( TAny* aDownload )

    {

    reinterpret_cast< RHttpDownload* >( aDownload )->Delete();

    }

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

// UpdateBufferL

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

//

template< typename bufType, typename descType >

LOCAL_C void UpdateBufferL( bufType*& aTargetBuf, const descType& aSourceBuf )

    {

    if ( aTargetBuf )

        {

        delete aTargetBuf;

        aTargetBuf = NULL;

        }

    if ( aSourceBuf.Length() )

        {

        aTargetBuf = aSourceBuf.AllocL();

        }

    }

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

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

// CRoHandlerDMgrWrapper::CRoHandlerDMgrWrapper

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

//

CRoHandlerDMgrWrapper::CRoHandlerDMgrWrapper() :

    CActive( CActive::EPriorityStandard ),

    iIapId( 0 ), iState( EInit )

    {

    CActiveScheduler::Add( this );

    }

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

// CRoHandlerDMgrWrapper::ConstructL

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

//

void CRoHandlerDMgrWrapper::ConstructL()

    {

    DRMDEBUGMETHOD( RoHdlrDMgrWrDebugLiterals::KMethConstructL() );

    // Get UID from process

    const TInt KRoHandlerDMgrWrapperUid = 0x101F7B92;

    iDlMgr.ConnectL( TUid::Uid( KRoHandlerDMgrWrapperUid ), *this, EFalse );

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

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

    }

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

// CRoHandlerDMgrWrapper::NewL

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

//

CRoHandlerDMgrWrapper* CRoHandlerDMgrWrapper::NewL()

    {

    DRMDEBUGMETHOD( RoHdlrDMgrWrDebugLiterals::KMethNewL() );

    CRoHandlerDMgrWrapper* self( CRoHandlerDMgrWrapper::NewLC() );

    CleanupStack::Pop( self );

    return self;

    }

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

// CRoHandlerDMgrWrapper::NewLC

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

//

CRoHandlerDMgrWrapper* CRoHandlerDMgrWrapper::NewLC()

    {

    DRMDEBUGMETHOD( RoHdlrDMgrWrDebugLiterals::KMethNewLC() );

    CRoHandlerDMgrWrapper* self( new ( ELeave ) CRoHandlerDMgrWrapper() );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CRoHandlerDMgrWrapper::~CRoHandlerDMgrWrapper

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

//

CRoHandlerDMgrWrapper::~CRoHandlerDMgrWrapper()

    {

    Cancel();

    DRMDEBUGMETHOD( RoHdlrDMgrWrDebugLiterals::KMethDestructor() );

    delete iTriggerUrl;

    delete iTriggerBuf;

    delete iFileName;

    delete iRoapEng;

#ifdef _DEBUG

    if ( iDlMgr.Handle() )

        {

        iDlMgr.Close();

        }

#else

    iDlMgr.Close();

#endif

    iFs.Close();

    }

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

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

//

void CRoHandlerDMgrWrapper::HandleRoapTriggerL( const TDesC8& aTrigger )

    {

    if ( iState != EInit || iWait.IsStarted() )

        {

        User::Leave( KErrNotReady );

        }

    UpdateBufferL< HBufC8, TDesC8 >( iTriggerBuf, aTrigger );

    Continue( EMeteringReportSubmit, KErrNone );

    iWait.Start();

    }

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

// CRoHandlerDMgrWrapper::DoDownloadRoapTriggerL

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

//

void CRoHandlerDMgrWrapper::DoDownloadRoapTriggerL( TMeterState aNextState )

    {

    RFile roapTrigger;

    TBool result( EFalse );

    DRMDEBUGMETHOD( RoHdlrDMgrWrDebugLiterals::KMethDoDownloadAndHandleRoapTriggerL() );

    // If no Trigger URL then nothing to download. So finish transaction

    if ( !iTriggerUrl || iTriggerUrl->Length() <= 0 )

        {

        Continue( EComplete, KErrNone );

        return;

        }

#ifndef RD_MULTIPLE_DRIVE

    User::LeaveIfError( roapTrigger.Temp(

#else //RD_MULTIPLE_DRIVE

    _LIT( KDrive, "%c:\\" );

    TInt driveNumber( -1 );

    TChar driveLetter;

    DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRam, driveNumber );

    iFs.DriveToChar( driveNumber, driveLetter );

#endif

    // create and start download

    RHttpDownload& download = iDlMgr.CreateDownloadL( *iTriggerUrl, result );

    // Put download for proper cleanup.

    TCleanupItem item( DeleteHttpDowload, &download );

    CleanupStack::PushL( item );

    CleanupClosePushL( roapTrigger );

    if ( result )

        {

        DRMDEBUG2(

            RoHdlrDMgrWrDebugLiterals::KFormatDoDlHdlRoapTrigL(),

            &RoHdlrDMgrWrDebugLiterals::KStrDlCreated() );

        iDownloadSuccess = EFalse;

        iConnectionError = EFalse;

        SetDefaultAccessPointL();

        User::LeaveIfError( download.SetFileHandleAttribute( roapTrigger ) );

        User::LeaveIfError( download.SetBoolAttribute(

                EDlAttrNoContentTypeCheck, ETrue ) );

        User::LeaveIfError( download.Start() );

        // wait until download is finished

        iState = aNextState;

        TRequestStatus* status( &iStatus );

        *status = KRequestPending;

        SetActive();

        }

    CleanupStack::PopAndDestroy( &roapTrigger );

    CleanupStack::Pop( &download ); // Left open for DoSaveRoapTrigger

    }

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

// CRoHandlerDMgrWrapper::DoSaveRoapTriggerL

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

//

void CRoHandlerDMgrWrapper::DoSaveRoapTriggerL( TMeterState aNextState )

    {

    // Check success of download

    DRMDEBUG2(

        RoHdlrDMgrWrDebugLiterals::KFormatDoDlHdlRoapTrigL(),

        &RoHdlrDMgrWrDebugLiterals::KStrDlFinished() );

    // Fetch download created in DoDownloadRoapTriggerL

    RHttpDownload* download = iDlMgr.FindDownload( *iTriggerUrl, KNullDesC8() );

    // Delete trigger URL so that it is possible to check

    // whether or not meteringResponse has PrUrl.

    delete iTriggerUrl;

    iTriggerUrl = NULL;

    // Put download for proper cleanup.

    TCleanupItem item( DeleteHttpDowload, download );

    CleanupStack::PushL( item );

    RFile roapTrigger;

    if ( !iDownloadSuccess )

        {

            if ( iConnectionError )

                {

                User::Leave( KErrCouldNotConnect );

                }

            else

                {

                User::Leave( KErrGeneral );

                }

        }

    User::LeaveIfError( roapTrigger.Open( iFs, *iFileName, EFileShareReadersOrWriters ) );

    CleanupClosePushL( roapTrigger );

    // Get filehandle of ROAP trigger

    const TInt KReadBufSize = 512;

    RBuf8 readBuf;

    readBuf.CleanupClosePushL();

    readBuf.CreateL( KReadBufSize );

    // Read file to buffer

    TInt triggerFileSize( 0 );

    User::LeaveIfError( roapTrigger.Size( triggerFileSize ) );

    if ( iTriggerBuf )

        {

        delete iTriggerBuf;

        iTriggerBuf = NULL;

        }

    iTriggerBuf = HBufC8::NewL( triggerFileSize );

    User::LeaveIfError( roapTrigger.Read( readBuf, KReadBufSize ) );

    iTriggerBuf->Des().Copy( readBuf );

    while ( readBuf.Length() == KReadBufSize )

        {

        User::LeaveIfError( roapTrigger.Read( readBuf, KReadBufSize ) );

        iTriggerBuf->Des().Append( readBuf );

        }

    // And let ROAP handle it...

    CleanupStack::PopAndDestroy( &readBuf );

    CleanupStack::PopAndDestroy( &roapTrigger );

    CleanupStack::PopAndDestroy( download );

    iFs.Delete( *iFileName );

    delete iFileName;

    iFileName=NULL;

    Continue( aNextState, KErrNone );

    }

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

// CRoHandlerDMgrWrapper::DoHandleRoapTriggerL

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

//

void CRoHandlerDMgrWrapper::DoHandleRoapTriggerL( TMeterState aNextState )

    {

    Roap::TTriggerType triggerType;

    Roap::TRiContextStatus contextStatus;

    Roap::TDomainOperation domainOperation;

    RPointerArray< HBufC8 > contentIds;

    iRoapEng = Roap::CRoapEng::NewL();

    iRoapEng->SetTriggerL( *iTriggerBuf, NULL, triggerType, contextStatus,

        domainOperation, contentIds );

    CleanupStack::PopAndDestroy( &contentIds );

    // if we have a valid RI context,

    // or if there is no user confirmation needed, do the ROAP

    if ( contextStatus != Roap::EInvalidContext )

        {

        iRoapEng->AcceptL( this, &iStatus );

        iState = aNextState;

        SetActive();

        }

    else

        {

        Continue( EComplete, KErrCancel );

        }

    }

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

// CRoHandlerDMgrWrapper::SetDefaultAccessPointL

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

//

void CRoHandlerDMgrWrapper::SetDefaultAccessPointL()

    {

    DRMDEBUGMETHOD( RoHdlrDMgrWrDebugLiterals::KMethSetDefaultAccessPointL() );

        {

        }

    }

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

// CRoHandlerDMgrWrapper::Continue

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

//

void CRoHandlerDMgrWrapper::Continue(

    CRoHandlerDMgrWrapper::TMeterState aNextState, TInt aError )

    {

    iState = aNextState;

    TRequestStatus* ownStatus = &iStatus;

    *ownStatus = KRequestPending;

    SetActive();

    User::RequestComplete( ownStatus, aError );

    }

// MHttpDownloadMgrObserver methods

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

// CRoHandlerDMgrWrapper::HandleDMgrEventL

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

//

void CRoHandlerDMgrWrapper::HandleDMgrEventL( RHttpDownload& aDownload,

        THttpDownloadEvent aEvent )

    {

    _LIT8( KDRMHelperMimeTypeROAPTrigger, "application/vnd.oma.drm.roap-trigger+xml" );

    DRMDEBUGMETHOD( RoHdlrDMgrWrDebugLiterals::KMethHandleDMgrEventL() );

    DRMDEBUG3( RoHdlrDMgrWrDebugLiterals::KFormatMembValInt(),

            &RoHdlrDMgrWrDebugLiterals::KMiDownLoadState(), aEvent.iDownloadState );

    DRMDEBUG3( RoHdlrDMgrWrDebugLiterals::KFormatMembValInt(),

            &RoHdlrDMgrWrDebugLiterals::KMiProgressState(), aEvent.iProgressState );

    if ( aEvent.iProgressState == EHttpContentTypeReceived )

        {

        DRMDEBUG2( RoHdlrDMgrWrDebugLiterals::KFormatMethHandleDMgrEventL(),

                &RoHdlrDMgrWrDebugLiterals::KStrEHttpContentTypeReceived() );

        // check received mimetype

        RBuf8 contentType;

        contentType.CleanupClosePushL();

        contentType.CreateL( KMaxContentTypeLength );

        User::LeaveIfError( aDownload.GetStringAttribute( EDlAttrContentType,

                contentType ) );

        if ( !contentType.FindF( KDRMHelperMimeTypeROAPTrigger ) )

            {

            // ROAP trigger found, continue download

            User::LeaveIfError( aDownload.Start() );

            }

        else

            {

            // wrong MIME type?, stop download

            iDownloadSuccess = EFalse;

            User::LeaveIfError( aDownload.Delete() );

            }

        CleanupStack::PopAndDestroy( &contentType );

        }

    if ( aEvent.iDownloadState == EHttpDlCreated )

        {

        DRMDEBUG2( RoHdlrDMgrWrDebugLiterals::KFormatMethHandleDMgrEventL(),

                &RoHdlrDMgrWrDebugLiterals::KStrEHttpDlCreated() );

        }

    else

        if ( aEvent.iProgressState == EHttpProgDisconnected )

            {

            DRMDEBUG2( RoHdlrDMgrWrDebugLiterals::KFormatMethHandleDMgrEventL(),

                    &RoHdlrDMgrWrDebugLiterals::KStrEHttpProgDisconnected() );