/*

* Copyright (c) 2002 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 CCodEngBase.   

*      

*

*/

// INCLUDE FILES

#include "CodEngBase.h"

#include "Connection.h"

#include "HttpLoader.h"

#include "CodSaver.h"

#include "FileSaver.h"

#include "RoapSaver.h"

#include "CodData.h"

#include "CodLoadObserver.h"

#include "CodError.h"

#include "CodStatus.h"

#include "CodPanic.h"

#include "CodUtil.h"

#include "CodLogger.h"

#include "RoapData.h"

#include "CodProgress.h"

#include "MediaObject.h"

#include "DownloadDataClient.h"

#include <AiwGenericParam.h>

#include <DocumentHandler.h>

#include <ApmStd.h>

#include <Oma2Agent.h>

#include <RoapDef.h>

#include <f32file.h>

#include <bodypart.h>

#include <SysUtil.h>

#include <pathinfo.h>

#include "CodDefs.h"

#include <CodUi.rsg>

#include <AknQueryDialog.h>

#include <stringloader.h>

#include <bautils.h>

#include "FileExt.h"

#ifdef __SYNCML_DM_FOTA

#include <fotaengine.h>

#include "FotaSaver.h"

/// FOTA Update Package type.

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

/// Default FOTA package id.

LOCAL_D const TInt KCodDefaultFotaPkgId = -1;

#endif /*def __SYNCML_DM_FOTA */

#ifdef RD_MULTIPLE_DRIVE

#include <centralrepository.h>

#include <driveinfo.h>

#include <browseruisdkcrkeys.h>

#endif //RD_MULTIPLE_DRIVE

#include <bldvariant.hrh>

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

const TInt KDownloadInfoIncrSize = 2*4096;     // used for DownloadInfo

/// Name of UTF-8 character set.

_LIT8( KCodUtf8, "utf-8" );

#ifdef RD_MULTIPLE_DRIVE

_LIT( KDefaultDriveListSep, ";" );

_LIT( KDefaultDriveList, "C;E" );

#endif

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

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

// CCodEngBase::~CCodEngBase()

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

//

EXPORT_C CCodEngBase::~CCodEngBase()

    {

    Cancel();

    delete iRoapData;

    if(iSaver)

        {

        iSaver->Cleanup( !Pausable() );

        }

    delete iSaver;

    delete iDocHandler;

    delete iLoader;

    delete iConn;

    delete iCodBuf;

    delete iData;

    iFs.Close();

    CLOG(( ECodEng, 2, _L("CCodEngBase::~CCodEngBase") ));

    CLOG(( ECodEng, 2, _L("*****************") ));

    }

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

// CCodEngBase::SetL()

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

//

EXPORT_C void CCodEngBase::SetL

        (

        const TDesC8& aBuf,

        TRequestStatus* aStatus,

        const CAiwGenericParamList* aParams,

        const RPointerArray<CBodyPart>* aParts

        )

    {

    CLOG(( ECodEng, 0, _L("-> CCodEngBase::SetL aParams=0x%x, aParts=0x%x"), \

        &aParams, aParts ));

    // Misuse asserts.

    __ASSERT_ALWAYS( aStatus, CodPanic( ECodInvalidArguments ) );

    __ASSERT_ALWAYS( iState == EInit || iState == EReady, \

                                            CodPanic( ECodOffState ) );

    // Internal asserts.

    __ASSERT_DEBUG( !iConn, CodPanic( ECodInternal ) );

    __ASSERT_DEBUG( !iLoader, CodPanic( ECodInternal ) );

    __ASSERT_DEBUG( !iParentStatus, CodPanic( ECodInternal ) );

    __ASSERT_DEBUG( !iSaver, CodPanic( ECodInternal ) );

    __ASSERT_DEBUG( !iCodBuf, CodPanic( ECodInternal ) );

    ResetPaths();

    delete iSaver;

    iSaver = NULL;

    iData->Reset();

    iParts = aParts;

    iParams = aParams;

    iType = TDataType();

    iHandler = TUid::Null();

    delete iRoapData;

    iRoapData = NULL;

    // Default parameters.

    TPtrC8 sourceUri;

    TPtrC8 charset( KCodUtf8 );

    iPreferredIap = 0;

    // Get params from GenericParams.

    if ( iParams )

        {

        CodUtil::GetDesParamLC( sourceUri, EGenericParamURL, *iParams );

        CodUtil::GetDesParamLC( charset, EGenericParamCharSet, *iParams );

        CodUtil::GetUint32Param( iPreferredIap, EGenericParamAccessPoint, *iParams );

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

        TUint32 AppUId(0);

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

        iAppUId.iUid = AppUId;

		// Generate COD DL Info folder name - C:\system\dmgr\<appuid>\codinfo\

		TBuf<KMaxPath> folderName;

		CODDownloadInfoFolder(folderName);

		// TO DO - Create the folder if it does not exist

        iCodDlInfoPath.Format( _L("%S%d"), &folderName,iDownloadId  );

        }

    iData->SetSourceUriL( sourceUri );

    iCodBuf = CodUtil::ConvertToUcs2L( aBuf, charset, iFs );

    if ( iParams )

        {

        CleanupStack::PopAndDestroy( 2 );   // Two pushed temp buffer.

        }

    iParentStatus = aStatus;

    *iParentStatus = KRequestPending;

    Continue( ESet );

    CLOG(( ECodEng, 0, _L("<- CCodEngBase::SetL (user 8-bit)") ));

    }

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

// CCodEngBase::SetL()

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

//

EXPORT_C void CCodEngBase::SetL

        (

        const TInt aDownloadId,

        const TUid aDlUid,

        //TRequestStatus* aStatus,        

        const RPointerArray<CBodyPart>* aParts

        )

	{

    ResetPaths();

    delete iSaver;

    iSaver = NULL;

    iData->Reset();

    iParts = aParts;

    //iParams = aParams;

    iType = TDataType();

    iHandler = TUid::Null();

    delete iRoapData;

    iRoapData = NULL;

    // Default parameters.

    TPtrC8 sourceUri;

    TPtrC8 charset( KCodUtf8 );

    iPreferredIap = 0;

  	//iLoader->LoadDownloadInfoL()

    //Read from info file

	iAppUId = aDlUid;

	iDownloadId = aDownloadId;

	TBuf<KMaxPath> folderName;

	CODDownloadInfoFolder(folderName); 

	iCodDlInfoPath.Format( _L("%S%d"), &folderName,iDownloadId  );

	// Download resumed after Pause 

	iResumedDownload = ETrue;   

   	LoadInfoFilesL();

	}

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

// CCodEngBase::CODDownloadInfoFolder()

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

//

void CCodEngBase::CODDownloadInfoFolder( TDes& aFolder ) const

    {

    aFolder.Format( KDownloadFolderFormat, 

                        &KDmDefaultDir, 

                        iAppUId,

                        &KInfoFilesCodDirName );

    }

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

// CCodEngBase::Data()

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

//

EXPORT_C const CCodData& CCodEngBase::Data() const

    {

    return *iData;

    }

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

// CCodEngBase::SetObserver()

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

//

EXPORT_C void CCodEngBase::SetObserver( MCodLoadObserver* aObserver )

    {

    CLOG(( ECodEng, 2, _L("CCodEngBase::SetObserver(0x%x)"), aObserver ));

    __ASSERT_ALWAYS( !(aObserver && iObserver), \

        CodPanic( ECodObserverAlreadySet ) );

    iObserver = aObserver;

    if ( iSaver )

        {

        iSaver->SetObserver( iObserver );

        }

    if ( iProgress )

        {

        iProgress->SetObserver( iObserver );

        }

    }

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

// CCodEngBase::Accept()

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

//

EXPORT_C void CCodEngBase::Accept( TRequestStatus* aStatus )

    {

    CLOG(( ECodEng, 0, _L("-> CCodEngBase::Accept") ));

    // Misuse asserts.

    __ASSERT_ALWAYS( iData->IsValid(), CodPanic( ECodInvalidData ) );

    __ASSERT_ALWAYS( aStatus, CodPanic( ECodInvalidArguments ) );

    __ASSERT_ALWAYS( iState == EReady, CodPanic( ECodOffState ) );

    // Internal asserts.

    __ASSERT_DEBUG( !iConn, CodPanic( ECodInternal ) );

    __ASSERT_DEBUG( !iLoader, CodPanic( ECodInternal ) );

    __ASSERT_DEBUG( !iParentStatus, CodPanic( ECodInternal ) );

    iParentStatus = aStatus;

    *iParentStatus = KRequestPending;	

    /*

	OMA 2: If the license element includes the order attribute and the order attribute

	is equal to the post. The contents of the license element MUST NOT be passed 

	to the License Agent unless the Media Object or Product is successfully downloaded		

    */

    if (iIsLicense && !iData->IsPostOrder())

	{

	  // dd2 case with license tag and order tag equals to "any", 

	  // so we should install the ROAP trigger as soon as it became available

	  Continue( EStartInstallRoap );

	}

    else

	{

	  // we should install MO first		

	  // 1) dd1 case

	  // 2) dd2 without license tag

	  // 3) dd2 with license tag and order tag = "POST"

	  __ASSERT_DEBUG( !iSaver, CodPanic( ECodInternal ) );

	  Continue( EStartConnect );

	}

    CLOG(( ECodEng, 0, _L("<- CCodEngBase::Accept") ));

    }

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

// CCodEngBase::Reject()

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

//

EXPORT_C void CCodEngBase::Reject( TRequestStatus* aStatus )

    {

    CLOG(( ECodEng, 0, _L("-> CCodEngBase::Reject") ));

    // Misuse asserts.

    __ASSERT_ALWAYS( iData->IsValid(), CodPanic( ECodInvalidData ) );

    __ASSERT_ALWAYS( aStatus, CodPanic( ECodInvalidArguments ) );

    __ASSERT_ALWAYS( iState == EReady, CodPanic( ECodOffState ) );

    // Internal asserts.

    __ASSERT_DEBUG( !iConn, CodPanic( ECodInternal ) );

    __ASSERT_DEBUG( !iLoader, CodPanic( ECodInternal ) );

    __ASSERT_DEBUG( !iParentStatus, CodPanic( ECodInternal ) );

//TODO

	if (!iIsLicense ) 

	{

    __ASSERT_DEBUG( !iSaver, CodPanic( ECodInternal ) );

	}

    iParentStatus = aStatus;

    *iParentStatus = KRequestPending;

    iResult = KErrAbort;

    iStatusCode = StatusCode( iResult, iState );

    Continue( EStartNotify );

    CLOG(( ECodEng, 0, _L("<- CCodEngBase::Reject") ));

    }

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

// CCodEngBase::Stop()

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

//

EXPORT_C void CCodEngBase::Stop()

    {

    CLOG(( ECodEng, 0, _L("-> CCodEngBase::Stop iState(%d)"), iState ));

    // This method is almost the same as DoCancel, yet works differently:

    //

    // When Cancel()->DoCancel() is called, this Active Object is not longer

    // active (set inactive by the framework). That is, RunL will not be called

    // after Cancel(). Anything that is going on stopped abruptly, without

    // any further processing, we are Done() (parent is completed).

    //

    // When Stop is called, we still stay active, so after cancelling the

    // outstanding request (if any), we will complete (RunL will be called)

    // with KErrCancel. That triggers further processing, so we are not Done()

    // yet (parent is not completed).

    //

    // Having this method comes from the logic of how a downloading is

    // cancelled: after cancel, we may still have to continue with notify. In

    // effect, a download must be cancelled twice to stop it; this method

    // supports the double-cancel.

    if ( iStopInProgress )

        {

        // Prevent reentrant calls.

        // Reentrancy normally should not be possible: we call some Cancel()

        // here, and that should not return and should not allow other object

        // to run until done. But it does: disconnecting the WAP stack

        // unfortunately includes waiting on the disconnect_cnf event.

        // This means that there IS a Cancel which allows other objects run.

        CLOG(( ECodEng, 0, _L("<- CCodEngBase::Stop already stopping") ));

        return;

        }

    iStopInProgress = ETrue;

    switch ( iState )

        {

        case ESet:

            {

            // Cancelled before we could start.

            delete iCodBuf;

            iCodBuf = NULL;

            // Own status already completed (by self-completion).

            __ASSERT_DEBUG( iStatus != KRequestPending, \

                CodPanic( ECodInternal ) );

            SelfComplete( KErrCancel );

            // Complete parent.

            iResult = KErrCancel;

            Done();

            break;

            }

        case EStartConnect:

        case EStartFetch:

        case EStartNotify:

            {

            // Already completed (by self-completion).

            __ASSERT_DEBUG( iStatus != KRequestPending, \

                CodPanic( ECodInternal ) );

            SelfComplete( KErrCancel );

            break;

            }

        case EConnect:

            {

            __ASSERT_DEBUG( iConn, CodPanic( ECodInternal ) );

            iConn->Cancel();

            // We are not Done() - parent request is still outstanding, we

            // are still active. RunL will be called with KErrCancel.

            break;

            }

        case EFetch:

            {

            if ( iObserver && iNotificationStatus == ELoad )

                {

                CLOG(( ECodEng, 3, \

                    _L("-> CCodEngBase::Stop notify StartCancelL") ));

                TRAP_IGNORE( iObserver->StartCancelL() );

                iNotificationStatus = ECancel;

                }

            __ASSERT_DEBUG( iLoader, CodPanic( ECodInternal ) );

            iLoader->Cancel();

            // We are not Done() - parent request is still outstanding, we

            // are still active. RunL will be called with KErrCancel.

            break;

            }

        case EInstall:

        case EInstallRoap:

            {

            __ASSERT_DEBUG( iSaver, CodPanic( ECodInternal ) );

            iSaver->CancelInstall();

            // We are not Done() - parent request is still outstanding, we

            // are still active. RunL will be called with KErrCancel.

            break;

            }

        case ENotify:

            {

            __ASSERT_DEBUG( iLoader, CodPanic( ECodInternal ) );

            iLoader->Cancel();

            // We are not Done() - parent request is still outstanding, we

            // are still active. RunL will be called with KErrCancel.

            break;

            }

        case EInit:

        case EReady:

        case EStartInstall:

        default:

            {

            if ( iObserver && iNotificationStatus == EPaused )

                {

                TRAP_IGNORE( iObserver->StartCancelL() );

                iNotificationStatus = ECancel;

                }

            // No request is outstanding, but as this is an user-callable

            // method, tolerate misuse (and do nothing).

            break;

            }

        }

    iStopInProgress = EFalse;

    CLOG(( ECodEng, 0, _L("<- CCodEngBase::Stop") ));

    }

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

// CCodEngBase::RemovableMedia()

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

//

EXPORT_C TBool CCodEngBase::RemovableMedia() const

    {

    return ( KDriveAttRemovable == iRemovableMediaStatus ) ? ETrue : EFalse ;

    }

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

// CCodEngBase::GetPath()

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

//

EXPORT_C TPtrC CCodEngBase::GetPath() const

    {

    if(!iData || !iData->Count() || !(*iData)[iData->ActiveDownload()]->iFullName )

        return KNullDesC();

    return *((*iData)[iData->ActiveDownload()]->iFullName);

    }

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

// CCodEngBase::GetDestFilePath()

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

//

EXPORT_C TPtrC CCodEngBase::GetDestFilePath (TInt aMOIndex ) const

    {

    if(iData && aMOIndex >=1 && aMOIndex <= iData->Count())

        {

        if((*iData)[aMOIndex]->iFullName)

        	return *((*iData)[aMOIndex]->iFullName);

        }

    return TPtrC( KNullDesC );

    }   

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

// CCodEngBase::GetType()

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

//

EXPORT_C const TDataType& CCodEngBase::GetType() const

    {

    return iType;

    }

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

// CCodEngBase::GetHandler()

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

//

EXPORT_C TUid CCodEngBase::GetHandler() const

    {