/*
* Copyright (c) 2005 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:  Implementation of class CRoapSaver.   
*
*/


// INCLUDE FILES

#include <RoapEng.h>
#include <RoapTrigger.h>
#include "RoapSaver.h"
#include "RoapData.h"
#include "CodLoadObserver.h"
#include "CodLogger.h"
#include "CodError.h"
#include "CodPanic.h"
#include "CodProgress.h"
#include "CodData.h"
#include <AiwGenericParam.h>

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

// ---------------------------------------------------------
// CRoapSaver::NewL()
// ---------------------------------------------------------
//
CRoapSaver* CRoapSaver::NewL
        (
        const TDesC8& aType,
        CRoapData*& aData,
        TCodProgress* aProgress,
        TInt aProgressBytes,
        const TFileName& aTempPath,
        const TFileName& aRootPath,
        const TFileName& aFname
        )
    {
    CRoapSaver* saver = new (ELeave) CRoapSaver
        ( aType, aData, aProgress, aProgressBytes, aTempPath, aRootPath, aFname );
    CleanupStack::PushL( saver );
    saver->ConstructL();
    CleanupStack::Pop( saver );
    return saver;
    }

// ---------------------------------------------------------
// CRoapSaver::~CRoapSaver()
// ---------------------------------------------------------
//
CRoapSaver::~CRoapSaver()
    {
    CLOG(( ECodEng, 2, _L("-> CRoapSaver::~CRoapSaver") ));
    delete iEng;
    delete iBuf;
    CLOG(( ECodEng, 2, _L("<- CRoapSaver::~CRoapSaver") ));
    }

// ---------------------------------------------------------
// CRoapSaver::OpenStoreL()
// ---------------------------------------------------------
//
void CRoapSaver::OpenStoreL()
    {
    CLOG(( ECodEng, 2, _L("-> CRoapSaver::OpenStoreL") ));
    __ASSERT_DEBUG( iState == EInit, CodPanic( ECodInternal ) );
    __ASSERT_DEBUG( !iBuf, CodPanic( ECodInternal ) );
    iSize = 0;
    iState = EStoreOpen;
    CLOG(( ECodEng, 2, _L("<- CRoapSaver::OpenStoreL") ));
    }
    
// ---------------------------------------------------------
// CRoapSaver::AppendData()
// ---------------------------------------------------------
//
TInt CRoapSaver::AppendData( const TDesC8& aData )
    {
    CLOG(( ECodEng, 4, \
        _L("-> CRoapSaver::AppendData (%d) bytes"), aData.Length() ));
//TODO: iState = EInstalling for dd2    __ASSERT_DEBUG( iState == EStoreOpen, CodPanic( ECodInternal ) );
    TInt err = CheckMaxSize( aData.Size() );
    if ( !err )
        {
        TInt needed = iSize + aData.Length();
        if ( !iBuf )
            {
            iBuf = HBufC8::New( needed );
            if ( !iBuf )
                {
                err = KErrNoMemory;
                }
            }
        if ( !err && needed > iBuf->Des().MaxLength() )
            {
            HBufC8* buf = iBuf->ReAlloc( needed );
            if ( buf )
                {
                iBuf = buf;
                }
            else
                {
                err = KErrNoMemory;
                }
            }
        if ( !err )
            {
            iBuf->Des().Append( aData );
            iSize += aData.Length();
            }
        }
    CLOG(( EHttpLoad, 2, _L("<- CFileSaver::AppendData returns (%d)"), err ));
    return err;
    }

// ---------------------------------------------------------
// CRoapSaver::CloseStore()
// ---------------------------------------------------------
//
void CRoapSaver::CloseStore()
    {
    CLOG(( ECodEng, 2, _L("CRoapSaver::CloseStore") ));
    iState = EStoreClosed;
    }

// ---------------------------------------------------------
// CRoapSaver::CheckResponseAttributesL()
// ---------------------------------------------------------
//
void CRoapSaver::CheckResponseAttributesL( const CCodData& /*aData*/ )
    {
    CLOG(( ECodEng, 2, _L("-> CRoapSaver::CheckResponseAttributesL") ));
//TODO: tmp EInstalling for dd2    __ASSERT_DEBUG( iState == EStoreClosed, CodPanic( ECodInternal ) );
#ifdef __TEST_COD_LOG
    TPtrC8 mime( iType.Des8() );
    CLOG(( ECodEng, 4, _L8("  MIME==<%S>, size(%d)"), &mime, iSize ));
#endif /* def __TEST_COD_LOG */

    if ( !iSize )
        {
        CLOG(( ECodEng, 4, _L("  0 bytes data") ));
        User::Leave( KErrCodAttributeMismatch );
        }

    // Compare content MIME type against descriptor.

    // Size is not checked, no exact match is required. Quote form spec:
    // "The storage size and the execution size are dependent on the
    // environment and may be different from the value of the size attribute.
    // The transport size may also be different, if compression or some
    // packaging format is used."
    //
    // There is a safety upper bound on the transaction size, that is already
    // applied. See SetMaxSize().


// TODO (??) type not checked, ROAP Trigger is always accepted.
// HACK HACK DRM HACK
//    if( iType != TDataType( aData.Type() ) )
//        {
//        CLOG(( ECodEng, 4, _L("  mismatch") ));
//        User::Leave( KErrCodAttributeMismatch );
//        }

    iState = ERespChecked;
    CLOG(( ECodEng, 2, _L("<- CRoapSaver::CheckResponseAttributesL (match)") ));
    }

// ---------------------------------------------------------
// CRoapSaver::InstallL()
// ---------------------------------------------------------
//
void CRoapSaver::InstallL( TRequestStatus* aStatus, const TDesC& aName, const TBool /*aAttached*/ )
    {
    CLOG(( ECodEng, 2, _L("-> CRoapSaver::InstallL") ));
//TODO:    __ASSERT_DEBUG( iState == ERespChecked, CodPanic( ECodInternal ) );
    __ASSERT_ALWAYS( aStatus, CodPanic( ECodInternal ) );
    __ASSERT_DEBUG( iBuf, CodPanic( ECodInternal ) );
//TODO:    __ASSERT_DEBUG( iType == TDataType( KOma2TriggerContentType ), \
//        CodPanic( ECodInternal ) );

#ifdef __TEST_COD_LOG
    TPtrC8 ptr( iBuf->Des() );
    CDUMP(( ECodEng, 2, _S("Trigger:"), _S("        "), \
        (const TUint8*)ptr.Ptr(), ptr.Size() ));
#endif /* def __TEST_COD_LOG */

    iContentName.Set( aName );  // TODO, must presist - use CodData instead?
    __ASSERT_DEBUG( !iEng, CodPanic( ECodInternal ) );
    iEng = Roap::CRoapEng::NewL();
    if ( iData )
        {
        iData->Reset();
        }
    else
        {
        iData = CRoapData::NewL();
        }
    iEng->SetTriggerL
        (
        *iBuf,
        iParams,
        iData->iType,
        iData->iContextStatus,
        iData->iDomainOperation,
        iData->iContentIdList
        );

//TODO:    __ASSERT_DEBUG( !iData->iRiAlias, CodPanic( ECodInternal ) );
    if ( iEng->Trigger().iRiAlias )
        {
        iData->iRiAlias = iEng->Trigger().iRiAlias->AllocL();
        }

#ifdef __TEST_COD_LOG
    CLOG(( ECodEng, 3, _L("  Type(%d)"), iData->iType ));
    CLOG(( ECodEng, 3, _L("  ContextStatus(%d)"), iData->iContextStatus ));
    CLOG(( ECodEng, 3, _L("  DomainOp(%d)"), iData->iDomainOperation ));
    for ( TInt i = 0; i < iData->iContentIdList.Count(); i++ )
        {
        ptr.Set( iData->iContentIdList[i]->Des() );
        CLOG(( ECodEng, 3, _L8("  ContentId #%d <%S>"), i, &ptr ));
        }
    if ( iData->iRiAlias )
        {
        ptr.Set( iData->iRiAlias->Des() );
        CLOG(( ECodEng, 3, _L8("  RiAlias <%S>"), &ptr ));
        }
    else
        {
        CLOG(( ECodEng, 3, _L8("  RiAlias NULL") ));
        }
#endif /* def __TEST_COD_LOG */
    
    if ( iObserver )
        {
        CLOG(( ECodEng, 3, \
            _L("CRoapSaver::StartRoapL notify RoapTriggerParsedL") ));
        iObserver->RoapTriggerParsedL( *iData );
        }

    // CodHandler implements 'auto-accept' for ROAP Trigger.
    // ROAP is initiated without user interaction.
    iEng->AcceptL( this, aStatus );
    iState = EInstalling;

    CLOG(( ECodEng, 2, _L("<- CRoapSaver::InstallL") ));
    }

// ---------------------------------------------------------
// CRoapSaver::CancelInstall()
// ---------------------------------------------------------
//
void CRoapSaver::CancelInstall()
    {
    CLOG(( ECodEng, 2, _L("-> CRoapSaver::CancelInstall") ));
    if ( iEng )
        {
        iEng->Cancel();
        }
    CLOG(( ECodEng, 2, _L("<- CRoapSaver::CancelInstall") ));
    }

// ---------------------------------------------------------
// CRoapSaver::ReleaseContent()
// ---------------------------------------------------------
//
void CRoapSaver::ReleaseContent( TFileName& aFname, TUid& aHandler )
    {
    CLOG(( ECodEng, 2, _L("CRoapSaver::ReleaseContent") ));
    // Note: assert EInstalling state, not EInstalled. This object never gets
    // EInstalled as the request status is not ours -> it does not know
    // when installing is completed.
//TODO: EStoreClose for dd2    __ASSERT_DEBUG( iState == EInstalling, CodPanic( ECodInternal ) );
    aFname = iFname;
    aHandler = iHandler;
    iFname = KNullDesC;
    iHandler = KNullUid;
    iContentName.Set( KNullDesC );
    delete iEng;
    iEng = NULL;
    iState = EInit;
    }

// ---------------------------------------------------------
// CRoapSaver::ReleaseFileName()
// ---------------------------------------------------------
//
void CRoapSaver::ReleaseFileName( TFileName& /*aFname*/)
{
}

// ---------------------------------------------------------
// CRoapSaver::Cleanup()
// ---------------------------------------------------------
//
void CRoapSaver::Cleanup( TBool /* aDeleteFile */)
    {
    CLOG(( ECodEng, 2, _L("-> CRoapSaver::Cleanup") ));
    if ( iEng )
        {
        iEng->Cancel();
#ifdef __TEST_COD_LOG
        TInt err =  // ('Log-only' variable.)
#endif /* def __TEST_COD_LOG */
        iEng->DoCleanup();
        CLOG(( ECodEng, 2, _L("  CRoapSaver::Cleanup err(%d)"), err ));
        delete iEng;
        iEng = NULL;
        }
    iContentName.Set( KNullDesC );
    iState = EInit;
    CLOG(( ECodEng, 2, _L("<- CRoapSaver::Cleanup") ));
    }

// ---------------------------------------------------------
// CRoapSaver::CRoapSaver()
// ---------------------------------------------------------
//
CRoapSaver::CRoapSaver
    (
    const TDesC8& aType,
    CRoapData*& aData,
    TCodProgress* aProgress,
    TInt aProgressBytes,
    const TFileName& aTempPath,
    const TFileName& aRootPath,
    const TFileName& aFname
    )
: CCodSaver( aType ),
  iData( aData ),
  iProgress( aProgress ),
  iProgressBytes( aProgressBytes ),
  iTempPath( aTempPath ),
  iRootPath( aRootPath ),
  iFname( aFname)
    {
    CLOG(( ECodEng, 2, _L("*** CRoapSaver::CRoapSaver") ));
    }

// ----------------------------------------------------------
// CRoapSaver::ConnectionConfL()
// ----------------------------------------------------------
//
TBool CRoapSaver::ConnectionConfL()
    {
    CLOG(( ECodEng, 2, _L("-> CRoapSaver::ConnectionConfL") ));
    TBool conf( EFalse );
    if ( iObserver )
        {
        CLOG(( ECodEng, 3, \
            _L("CRoapSaver::ConnectionConfL notify ConnectionConfL") ));
        conf = iObserver->ConfirmConnectL();
        }
    CLOG(( ECodEng, 2, _L("<- CRoapSaver::ConnectionConfL (%d)"), conf ));
    return conf;
    }
    
// ----------------------------------------------------------
// CRoapSaver::ContactRiConfL()
// ----------------------------------------------------------
//
TBool CRoapSaver::ContactRiConfL()
    {
    CLOG(( ECodEng, 2, _L("CRoapSaver::ContactRiConfL") ));
    // CodHandler implements 'auto-accept' for ROAP Trigger.
    return ETrue;
    }
    
// ----------------------------------------------------------
// CRoapSaver::TransIdConfL()
// ----------------------------------------------------------
//
TBool CRoapSaver::TransIdConfL()
    {
    CLOG(( ECodEng, 2, _L("CRoapSaver::TransIdConfL") ));
    return EFalse;
    }
    
// ----------------------------------------------------------
// CRoapSaver::RightsObjectDetailsL()
// ----------------------------------------------------------
//
void CRoapSaver::RightsObjectDetailsL
( const RPointerArray<CDRMRights>& /*aRightsList*/ )
    {
    CLOG(( ECodEng, 2, _L("CRoapSaver::RightsObjectDetailsL") ));
    }
		    
// ----------------------------------------------------------
// CRoapSaver::ContentDownloadInfoL()
// ----------------------------------------------------------
//
void CRoapSaver::ContentDownloadInfoL
( TPath& aTempFolder, TFileName& aContentName, TInt& aMaxSize )
    {
    aTempFolder = iTempPath;
    aContentName = iContentName;
    aMaxSize = iMaxSize;        // TODO must to be set.
    }

// ----------------------------------------------------------
// CRoapSaver::ContentDetailsL()
// ----------------------------------------------------------
//
void CRoapSaver::ContentDetailsL
( const TDesC& aPath, const TDesC8& aType, const TUid& aAppUid )
    {
    iFname = aPath;
    iType = aType;
    iHandler = aAppUid;
    }
                                      
// ----------------------------------------------------------
// CRoapSaver::HandleDCFPartL()
// ----------------------------------------------------------
//
void CRoapSaver::HandleDCFPartL( const TDesC8& /*aFilename*/ )
    {
    CLOG(( ECodEng, 2, _L("CRoapSaver::HandleDCFPartL") ));
    // DRM Engine does not support multipart ROAP response yet.
    // This method will never be called.
    User::Leave( KErrNotSupported );
    }
        
// ----------------------------------------------------------
// CRoapSaver::RoapProgressInfoL()
// ----------------------------------------------------------
//
void CRoapSaver::RoapProgressInfoL( const TInt aProgressInfo )
    {
    CLOG(( ECodEng, 2, _L("CRoapSaver::RoapProgressInfoL (%d)"), \
        aProgressInfo ));
    if ( iProgress )
        {
        iProgress->SetAmountL( aProgressInfo );
        }
    }


// ----------------------------------------------------------
// CRoapSaver::ErrorUrlL()
// ----------------------------------------------------------
//
void CRoapSaver::ErrorUrlL( const TDesC8& /* aErrorUrl */)
{
	
}
// ----------------------------------------------------------
// CRoapSaver::PostResponseUrlL()
// ----------------------------------------------------------
//
void CRoapSaver::PostResponseUrlL( const TDesC8& aPrUrl )
    {
    CLOG(( ECodEng, 2, _L("-> CRoapSaver::PostResponseUrlL") ));
    CLOG(( ECodEng, 2, _L("aPrUrl = '%S'"), &aPrUrl ));

    //Send an event to MCodLoadObserver which sends an event to DownloadMgr, which handles the 
    // PostResponse URL like NextUriL.
    if ( iObserver )
        {
        iObserver->HandleRoapPostResponseUrlL( aPrUrl );
        }

    CLOG(( ECodEng, 2, _L("<- CRoapSaver::PostResponseUrlL") ));

    }