/*

* 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 CCodDownloadImpl.   

*

*/

// INCLUDE FILES

#include <bldvariant.hrh>

#include <AiwGenericParam.h>

#include <DocumentHandler.h>

#include <apgcli.h>

#include <eikenv.h>

#include <StringLoader.h>

#include <ErrorUi.h>

#include <DcfRep.h>

#include <RoapDef.h>

#include <DRMCommon.h>

#include <aknmessagequerydialog.h>

#include <hlplch.h>             

#include <MultipartParser.h>

#include <AknQueryDialog.h>

#include "CodDownloadImpl.h"

#include "CodUiPanic.h"

#include <CodStatus.h>

#include <CodDefs.h>

#include <CodError.h>

#include <CodEng.h>

#include <CodData.h>

#include <RoapData.h>

#include <DdEng.h>

#include <CodUtil.h>

#include "CodUiResource.h"

#include <CodUi.rsg>

#include "CodViewDialog.h"

#include "CodLogger.h"

#include "CodDialog.h"

#include "CodUi.hrh"

#include <pathinfo.h>

#include <Oma2Agent.h>

#include <bldvariant.hrh>

#include "CodConfirm.h" 

#include  <bautils.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif

// ================= CONSTANTS =======================

/// COD MIME type.

_LIT8( KCodDataType, COD_MIME_TYPE );

/// multipart/related type.

_LIT8( KMultipartRelatedDataType, "multipart/related" );

#ifdef __SYNCML_DM_FOTA

/// FOTA Update Package type.

_LIT8( KFotaPackageDataType, "application/vnd.nokia.swupd.dp2" );

#endif /*def __SYNCML_DM_FOTA */

/// UID of Wml Browser.

LOCAL_D const TInt KCodWmlBrowserUid = 0x10008D39;

/// Message prefix, to launch browser with URL.

_LIT( KCodMsgLaunchBrowserWithUrl, "4 " );

/// Reserved word "local".

_LIT8( KCodReservedWordLocal, "local" );

/// Reserved word "back".

_LIT8( KCodReservedWordBack, "back" );

/// For launching more info DRM_HLP_REGISTRATION

_LIT(KDRM_HLP_REGISTRATION,"DRM_HLP_REGISTRATION"); 

/// Next Line

_LIT( KNextLine, "\n" );

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

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

// CCodDownloadImpl::NewL()

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

//

EXPORT_C CCodDownloadImpl* CCodDownloadImpl::NewL

        (

        CCodDownload& aProxy,

        const TDesC8& aBuf,

        const TDesC8& aType,

        MCodDownloadObserver& aObserver,

        CEikonEnv* aEikEnv,

        const TDesC8* aMultipartBoundary,

        const TDesC16* aMultipartUrl

        )

    {

    CLOG(( 2, _L8("-> CCodDownloadImpl::NewL aType<%S> aEikEnv(0x%x)"), \

        &aType, aEikEnv ));

    CCodDownloadImpl* download =

        new (ELeave) CCodDownloadImpl( aProxy, aObserver, aEikEnv );

    CleanupStack::PushL( download );

    download->ConstructL( aBuf, aType, aMultipartBoundary, aMultipartUrl );

    CleanupStack::Pop( download );

    CLOG(( 2, _L8("<- CCodDownloadImpl::NewL") ));

    return download;

    }

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

// CCodDownloadImpl::NewL()

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

//

EXPORT_C CCodDownloadImpl* CCodDownloadImpl::NewL

        (

        CCodDownload& aProxy,

        const TInt aDownloadId,

        const TUid aDlUid,

        const TDesC8& aType,

        MCodDownloadObserver& aObserver,

        CEikonEnv* aEikEnv,

        const TDesC8* aMultipartBoundary,

        const TDesC16* aMultipartUrl 

        )

    {

    CLOG(( 2, _L8("-> CCodDownloadImpl::NewL aType<%S> aEikEnv(0x%x)"), \

        &aType, aEikEnv ));

    CCodDownloadImpl* download =

        new (ELeave) CCodDownloadImpl( aProxy, aObserver, aEikEnv );

    CleanupStack::PushL( download );

    download->ConstructL( aDownloadId, aDlUid, aType, aMultipartBoundary, aMultipartUrl );

    CleanupStack::Pop( download );

    CLOG(( 2, _L8("<- CCodDownloadImpl::NewL") ));

    return download;

    }

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

// CCodDownloadImpl::~CCodDownloadImpl()

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

//

EXPORT_C CCodDownloadImpl::~CCodDownloadImpl()

    {

    CLOG(( 2, _L("*** -> CCodDownloadImpl::~CCodDownloadImpl") ));

    Cancel();

    delete iParams;

    iParts.ResetAndDestroy();

    delete iBuf;

    delete iEng;

    delete iUiResource;

    delete iErrorUi;

    delete iDocHandler;

    delete iDocParams;

    delete iPostResponseURL;

    iFs.Close();

    CLOG(( 2, _L("*** <- CCodDownloadImpl::~CCodDownloadImpl") ));

    }

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

// CCodDownloadImpl::StartL()

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

//

EXPORT_C void CCodDownloadImpl::StartL( const CAiwGenericParamList* aParams )

    {

    CLOG(( 2, _L("-> CCodDownloadImpl::StartL") ));

   // __ASSERT_DEBUG( iState == EInit , CodUiPanic( ECodUiRequestPending ) );

    __ASSERT_DEBUG( !IsActive(), CodUiPanic( ECodUiRequestPending ) );

    iAutoAccept = EFalse;

    iSilentMode = EFalse;

    iSuppressNextUrl = EFalse;

    iSuppressLaunch = EFalse;

    iFota = EFalse;

    iParams->Reset();

    if ( aParams )

        {

        // We must copy parameters, there is no guarantee that the caller

        // keeps the original during the whole download process.

        iParams->AppendL( *aParams );

        CodUtil::GetBoolParam

            ( iSilentMode, EGenericParamSilentDownload, *iParams );

        CodUtil::GetBoolParam( iAutoAccept,

            EGenericParamSuppressDownloadConfirmation, *iParams );

        CodUtil::GetBoolParam

            ( iSuppressNextUrl, EGenericParamSuppressNextUrl, *iParams );

        CodUtil::GetBoolParam

            ( iSuppressLaunch, EGenericParamSuppressLaunch, *iParams );

        CodUtil::GetUint32Param( iDownloadId, EGenericParamDownloadId, *iParams );

        TUint32 intAppUId(0);

        CodUtil::GetUint32Param( intAppUId, EGenericParamApplication, *iParams );

        iAppUId.iUid = intAppUId;

#ifdef __SYNCML_DM_FOTA

        TInt i( 0 );

        if ( iParams->FindFirst( i, EGenericParamFotaPkgId ) )

            {

            CLOG(( 2, _L("  EGenericParamFotaPkgId set"), &iProxy ));

            iFota = ETrue;

            }

#endif /*def __SYNCML_DM_FOTA */

        }

    if(iDownloadPaused)

    {

        iEng->Start(aParams,&iStatus);

        SetActive();

        iState = ELoad;

        iProgress.iState = TCodDownloadProgress::EInProgress;

        TRAP_IGNORE( iObserver.CodEventL( iProxy, MCodDownloadObserver::EStart ) );

        return;

    }

	iEng->SetL( iDescriptor, &iStatus, iParams, &iParts );

    SetActive();

    // Warning: no leave after this point!

    iState = ESet;

    ResetProgress();

    iProgress.iState = TCodDownloadProgress::EInProgress;

    CLOG(( 2, _L("CodEventL(0x%x,EStart)"), &iProxy ));

    TRAP_IGNORE( iObserver.CodEventL( iProxy, MCodDownloadObserver::EStart ) );

    CLOG(( 2, _L("<- CCodDownloadImpl::StartL") ));

    }

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

// CCodDownloadImpl::Stop()

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

//

EXPORT_C void CCodDownloadImpl::Stop()

    {

    CLOG(( 2, _L("-> CCodDownloadImpl::Stop") ));

    iEng->Stop();

    delete iDocHandler;

    iDocHandler = NULL;

    delete iDocParams;

    iDocParams = NULL;

    CLOG(( 2, _L("<- CCodDownloadImpl::Stop") ));

    }

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

// CCodDownloadImpl::Progress()

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

//

EXPORT_C const TCodDownloadProgress& CCodDownloadImpl::Progress() const

    {

    CLOG(( 2, _L("CCodDownloadImpl::Progress state(%d) error(%d) cur(%d) max(%d)"), \

        iProgress.iState, \

        iProgress.iError, \

        iProgress.iBytesCur, \

        iProgress.iBytesMax ));

    return iProgress;

    }

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

// CCodDownloadImpl::Name()

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

//

EXPORT_C TPtrC CCodDownloadImpl::Name()

    {

#ifdef __TEST_COD_LOG

    TPtrC ptr( iEng->Data().Name() );

    CLOG(( 2, _L("CCodDownloadImpl::Name returns<%S>"), &ptr ));

#endif /* def __TEST_COD_LOG */

    if(iEng->Data().Count() > 0)

        return (*iEng->Data()[iEng->Data().ActiveDownload()]).Name();

    else

        return KNullDesC();

    }

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

// CCodDownloadImpl::Type()

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

//

EXPORT_C TPtrC8 CCodDownloadImpl::Type() const

    {

#ifdef __TEST_COD_LOG

    if(iEng->Data().Count() > 0)

        {

        TPtrC8 ptr( (*iEng->Data()[iEng->Data().ActiveDownload()]).Type() );

        CLOG(( 2, _L8("CCodDownloadImpl::Type returns<%S>"), &ptr ));

        }

#endif /* def __TEST_COD_LOG */

    if(iEng->Data().Count() > 0)

        return (*iEng->Data()[iEng->Data().ActiveDownload()]).Type();

    else

        return KNullDesC8();

    }

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

// CCodDownloadImpl::GetPath()

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

//

EXPORT_C TPtrC CCodDownloadImpl::GetPath() const

    {

#ifdef __TEST_COD_LOG

    TPtrC ptr( iEng->GetPath() );

    CLOG(( 2, _L("CCodDownloadImpl::GetPath returns<%S>"), &ptr ));

#endif /* def __TEST_COD_LOG */

    return iEng->GetPath();

    }

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

// CCodDownloadImpl::GetDestFilePath()

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

//

EXPORT_C TPtrC CCodDownloadImpl::GetDestFilePath (TInt aMOIndex ) const

    {

    return iEng->GetDestFilePath(aMOIndex);

    }   

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

// CCodDownloadImpl::ServiceFlowL()

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

//

EXPORT_C void CCodDownloadImpl::ServiceFlowL()

    {

    CLOG(( 2, _L("-> CCodDownloadImpl::ServiceFlowL") ));

    if ( iState != ELoadDone )

        {

        // No completed download!

        User::Leave( KErrNotReady );

        }

    TBool done( ETrue );

    TRAPD( err, done = DoServiceFlowL() );

    if ( done || err )

        {

        Done();

        }

    CLOG(( 2, _L("<- CCodDownloadImpl::ServiceFlowL") ));

    }

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

// CCodDownloadImpl::NextUrlL()

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

//

EXPORT_C HBufC8* CCodDownloadImpl::NextUrlL() const

    {

    HBufC8* absUrl = NULL;

    TBool back( EFalse );

    // Empty string is returned while in progress.

    if ( iState == ELoadDone || iState == EServiceFlow || iState == EInit )

        {

        TPtrC8 url( NextUrlAttr( back ) );

        if ( url.Length() )

            {

            absUrl = CodUtil::AbsoluteUrlLC( iEng->Data().SourceUri(), url );

            CleanupStack::Pop( absUrl );

            }

        }

    if ( !absUrl )

        {

        absUrl = HBufC8::NewL( 0 );

        }

    return absUrl;

    }

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

// CCodDownloadImpl::PostResponseUrlL()

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

//

EXPORT_C HBufC8* CCodDownloadImpl::GetPostResponseUrlL() const

    {

    return iPostResponseURL;

    }

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

// CCodDownloadImpl::UpdatedDDUriL()

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

//

EXPORT_C HBufC8* CCodDownloadImpl::UpdatedDDUriL() const

    {

    HBufC8* absUrl = NULL;

    absUrl = CodUtil::AbsoluteUrlLC( iEng->Data().UpdatedDDUriL(), iEng->Data().UpdatedDDUriL() );

    CleanupStack::Pop( absUrl );

    if ( !absUrl )

        {

        absUrl = HBufC8::NewL( 0 );

        }      

    return absUrl;

    }

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

// CCodDownloadImpl::UpdatedDownlaodDataL()

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

//

EXPORT_C HBufC8* CCodDownloadImpl::UpdatedDownloadDataL() const

    {

    return (iEng->UpdatedDownloadDataL());

    }

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

// CCodDownloadImpl::UpdatedTrackDataL()

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

//

EXPORT_C HBufC8* CCodDownloadImpl::UpdatedTrackDataL(TInt& aValue) const

    {

    return (iEng->UpdatedTrackDataL(aValue));

    }

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

// CCodDownloadImpl::RemovableMedia()

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

//

EXPORT_C TBool CCodDownloadImpl::RemovableMedia() const

    {

    TBool removable = iEng->RemovableMedia();

    CLOG(( 2, _L("CCodDownloadImpl::RemovableMedia (%d)"), removable ));

    return removable;

    }

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

// CCodDownloadImpl::UserData()

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

//

EXPORT_C TAny* CCodDownloadImpl::UserData() const

    {

    CLOG(( 2, _L("CCodDownloadImpl::UserData returns 0x%x"), iUserData ));

    return iUserData;

    }

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

// CCodDownloadImpl::SetUserData()

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

//

EXPORT_C void CCodDownloadImpl::SetUserData( TAny* aUserData )

    {

    CLOG(( 2, _L("CCodDownloadImpl::SetUserData (0x%x)"), aUserData ));

    iUserData = aUserData;

    }

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

// CCodDownloadImpl::SetCodDlAttached()

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

//

EXPORT_C void CCodDownloadImpl::SetCodDlAttached(const TBool aValue)

    {

    CLOG(( 2, _L("CCodDownloadImpl::SetCodDlAttached") ));

    iEng->SetCodDlAttached(aValue);

	iAttached = aValue;

    }

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

// CCodDownloadImpl::ConstructL()

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

//

void CCodDownloadImpl::ConstructL

        (

        const TDesC8& aBuf,

        const TDesC8& aType,

        const TDesC8* aMultipartBoundary,

        const TDesC16* aMultipartUrl

        )

    {

    iBuf = aBuf.AllocL();

    // By default, use the whole buffer and passed type.

    iDescriptor.Set( *iBuf );

    TDataType type( aType );

    // For multipart content, use the first part.

    // If there is no such (or cannot get it), fail on MIME check below.

    if ( type == TDataType( KMultipartRelatedDataType ) &&

         aMultipartBoundary && aMultipartUrl )

        {

        MultipartParser::ParseL

            ( *iBuf, aType, *aMultipartBoundary, *aMultipartUrl, iParts );

        if ( iParts.Count() )

            {

            // Use first part of multipart/related.

            iDescriptor.Set( iParts[0]->Body() );

            type = iParts[0]->ContentType();

            }

        }

    // Now iDescriptor and type are either the whole buffer and its type,

    // or those of the first part of multipart.

    if ( type == TDataType( KCodDataType ) )

        {

        iCod = ETrue;

        iEng = CCodEng::NewL( NULL, this );

        }

    else if ( type == TDataType( KDdDataType ) )

        {

        iCod = EFalse;

        iEng = CDdEng::NewL( NULL, this );

        iEng->SetDd2Type(EFalse);

        }

    else if ( type == TDataType( KDd2DataType ) )

        {

        iCod = EFalse;

        iEng = CDdEng::NewL( NULL, this );

        iEng->SetDd2Type(ETrue);

        }

    else

        {

        if( type == TDataType(KNullDesC8))

        	{

        	iEng = CDdEng::NewL( NULL, this );

        	}

        else

        	{

        	User::Leave( KErrNotSupported );

        	}

        }

    // HACK: Priority set lower than DownloadManagerUiLib's download list.

    // In-download queries (currently, ROAP device registration query)

    // need to come on top of Download Manager's download list.

    iEng->SetPriority( CActive::EPriorityStandard - 1 );

    if ( iEikEnv )

        {

        iUiResource = CCodUiResource::NewL( *iEikEnv );

        iErrorUi = CErrorUI::NewL( *iEikEnv );

        }

    iParams = CAiwGenericParamList::NewL();

    }

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