/*

 * Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies).

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

 *

 */

#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 <StringLoader.h>

#include <data_caging_path_literals.hrh>

#include <es_enum.h> // tconnectioninfo

#include <es_enum_partner.h> // TConnectionInfoV2

#include <es_sock.h> // rconnection rsocket

#include <AknProgressDialog.h> // avkon classes

#include <eikprogi.h>

#include <ConeResLoader.h>

#include <apparc.h>

#include <DrmUtilityDmgrWrapper.rsg>

#include <RoapEng.h>

#include <RoapDef.h>

#include <RoapObserver.h>

// including files related to qt changes

#include <qstring.h>

#include <downloadmanager.h>

#include <download.h>

#include <dmcommon.h>

#include <downloadevent.h>

#include "RoapSyncWrapper.h"

#include "RoapDef.h"

#include "DrmUtilityDmgrWrapper.h"

#include "DrmUtilityDmgrWrapperLogger.h"

#include "drmutilityconnection.h"

#include "buffercontainers.h" //CnameContainer etc.

#include "cleanupresetanddestroy.h"

#include "buffercontainers.h"

#include "qdrmutilitydmgreventhandler.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "DrmUtilityDmgrWrapperTraces.h"

#endif

#ifndef RD_MULTIPLE_DRIVE

_LIT( KDriveZ, "z:" );

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

#else

_LIT( KRomDriveFormatter, "%c:" );

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

#endif

_LIT( KCDrmUtilityDmgrWrapperResFileName,"DrmUtilityDmgrWrapper.rsc" );

const TInt KProgressInfoFinalValue(200);

const TInt KProgressInfoIncrementSmall(5);

const TInt KProgressInfoIncrementMedium(10);

const TInt KProgressInfoIncrementLarge(30);

using namespace WRT;

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

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

// ClearIfNotRoapTemporaryError

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

//

void ClearIfNotRoapTemporaryError(TInt aError, HBufC8*& aBuffer)

    {

    // ROAP ERROR CODES

    switch (aError)

        {

        case KErrRoapGeneral:

        case KErrRoapServer:

        case KErrRoapDomainFull:

        case KErrRoapNotRegistered:

            break;

        default:

            delete aBuffer;

            aBuffer = NULL;

            break;

        }

    }

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

// Calls the appropriate member function of the object during object cleanup

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

//

template<class _Ty, class _Tf>	class mem_auto_ptr 

	{

	public:

		explicit mem_auto_ptr(_Ty _P = 0, _Tf _F = 0) 

			: _Owns(_P != 0), _Ptr(_P), _Fn(_F) 

				{}

		mem_auto_ptr(const mem_auto_ptr<_Ty,_Tf>& _Y) 

			: _Owns(_Y._Owns), _Ptr(_Y.release()), _Fn(_Y.function()) 

				{}

		mem_auto_ptr<_Ty,_Tf>& operator=(const mem_auto_ptr<_Ty,_Tf>& _Y) 

			{

			if (this != &_Y)

				{

				_Fn = _Y.function();

				if (_Ptr != _Y.get())

					{

					if (_Owns)

						delete _Ptr;

					_Owns = _Y._Owns; 

					}

				else if (_Y._Owns)

					_Owns = true;

				_Ptr = _Y.release(); 

				}

			return (*this); 

			}

		~mem_auto_ptr()

			{

			if (_Owns)

				{

				(_Ptr->*_Fn)();

				}

			}

		_Ty& operator*() const 

			{

			return (*get()); 

			}

		_Ty *operator->() const 

			{

			return (get()); 

			}

		_Ty *get() const 

			{

			return (_Ptr); 

			}

		_Ty *release() const 

			{

			((mem_auto_ptr<_Ty,_Tf> *)this)->_Owns = false;

			return (_Ptr); 

			}

		_Tf *function() const

			{

			return (_Fn);

			}

	private:

		bool _Owns;

		_Ty _Ptr;

		_Tf _Fn;

	};

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

// 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 ========

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

// CDrmUtilityDmgrWrapper::CDrmUtilityDmgrWrapper

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

//

CDrmUtilityDmgrWrapper::CDrmUtilityDmgrWrapper() :

            CActive(CActive::EPriorityStandard),

            iUseCoeEnv(EFalse), iIapId(0), iState(EInit)

    {

    CActiveScheduler::Add(this);

    }

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

// CDrmUtilityDmgrWrapper::ConstructL

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

//

void CDrmUtilityDmgrWrapper::ConstructL()

    {

    CLOG_WRITE( "DMgrWrapper::ConstructL" );

    const TInt KDrmUtilityDmgrWrapperUid = 0x102830FE;

    iConnection = DRM::CDrmUtilityConnection::NewL(ETrue);

    try

	    {

	    QString drmUtilityDmgrWrapperUid(QString::number(KDrmUtilityDmgrWrapperUid));

	    iDlMgr = q_check_ptr(new DownloadManager(drmUtilityDmgrWrapperUid));

	    }

	catch(const std::exception& exception)

		{

		qt_symbian_exception2LeaveL(exception);

		}

    iProgressInfo = NULL;

    iProgressNoteDialog = NULL;

    iDialogDismissed = ETrue;

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

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

    }

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

// CDrmUtilityDmgrWrapper::NewL

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

//

CDrmUtilityDmgrWrapper* CDrmUtilityDmgrWrapper::NewL()

    {

    CLOG_WRITE( "DMgrWrapper::NewL" );

    CDrmUtilityDmgrWrapper* self(CDrmUtilityDmgrWrapper::NewLC());

    CleanupStack::Pop(self);

    return self;

    }

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

// CDrmUtilityDmgrWrapper::NewLC

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

//

CDrmUtilityDmgrWrapper* CDrmUtilityDmgrWrapper::NewLC()

    {

    CLOG_WRITE( "DMgrWrapper::NewLC" );

    CDrmUtilityDmgrWrapper* self(new (ELeave) CDrmUtilityDmgrWrapper());

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CDrmUtilityDmgrWrapper::~CDrmUtilityDmgrWrapper

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

//

CDrmUtilityDmgrWrapper::~CDrmUtilityDmgrWrapper()

    {

    CLOG_WRITE( "DMgrWrapper destructor" );

    Cancel();

    if (iProgressNoteDialog)

        {

        // deletes the dialog

        TRAPD( err, iProgressNoteDialog->ProcessFinishedL() );

        if (err)

            {

            delete iProgressNoteDialog;

            }

        iProgressNoteDialog = NULL;

        }

    delete iErrorUrl;

    delete iPostResponseUrl;

    delete iConnection;

    delete iTriggerUrl;

    delete iTriggerBuf;

    delete iFileName;

    delete iRoapEng;

    iDownload->cancel();

    delete iDlMgr;

    delete iDrmUtilityDmgrEventHandler;

    iFs.Close();

    }

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

// CDrmUtilityDmgrWrapper::DownloadAndHandleRoapTriggerL

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

//

void CDrmUtilityDmgrWrapper::DownloadAndHandleRoapTriggerL(const HBufC8* aUrl)

    {

    CLOG_WRITE( "DMgrWrapper::DownloadAndHandleRoapTriggerL" );

    iUseCoeEnv = EFalse;

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

        {

        User::Leave(KErrNotReady);

        }

    UpdateBufferL<HBufC8, TDesC8> (iTriggerUrl, *aUrl);

    CompleteToState(EInit, KErrNone);

    iWait.Start();

    }

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

// CDrmUtilityDmgrWrapper::DownloadAndHandleRoapTriggerL

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

//

void CDrmUtilityDmgrWrapper::DownloadAndHandleRoapTriggerL(

        const HBufC8* aUrl, CCoeEnv& aCoeEnv)

    {

    CLOG_WRITE( "DMgrWrapper::DownloadAndHandleRoapTriggerL" );

    iCoeEnv = &aCoeEnv;

    iUseCoeEnv = ETrue;

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

        {

        User::Leave(KErrNotReady);

        }

    UpdateBufferL<HBufC8, TDesC8> (iTriggerUrl, *aUrl);

    CompleteToState(EInit, KErrNone);

    iWait.Start();

    }

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

// CDrmUtilityDmgrWrapper::GetErrorUrlL

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

//

HBufC8* CDrmUtilityDmgrWrapper::GetErrorUrlL()

    {

    if (iErrorUrl)

        {

        return iErrorUrl->AllocL();

        }

    return NULL;

    }

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

// CDrmUtilityDmgrWrapper::DoConnectL

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

//

void CDrmUtilityDmgrWrapper::DoConnectL(TDownloadState aNextState)

    {

    iConnection->ConnectL(&iStatus);

    if (iUseCoeEnv && iProgressInfo)

        {

        iProgressInfo->SetAndDraw(0);

        }

    iState = aNextState;

    SetActive();

    }

/////

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

// CDrmUtilityDmgrWrapper::DoDownloadRoapTriggerL

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

//

void CDrmUtilityDmgrWrapper::DoDownloadRoapTriggerL(TDownloadState aNextState)

    {

    // Fetch name of opend connection to be used as part of DMGR

    // initialisation

    TUint32 iapId(0);

    if (iConnection->IsConnected(iapId))

        {

    	const QVariant qIapId( static_cast<unsigned long long>(iapId) );

		iDlMgr->setAttribute( WRT::ClientName, qIapId );

        }

    RFile roapTrigger;

    CleanupClosePushL(roapTrigger);

    DRM::CFileNameContainer* triggerFileName(NULL);

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

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

        {

        if (iUseCoeEnv && iProgressInfo)

            {

            // No PrUrl found. Progess is complete.

            iProgressInfo->SetAndDraw(KProgressInfoFinalValue);

            }

        CompleteToState(EComplete, KErrNone);

        return;

        }

    TPtrC8 KNullPtr8(NULL, 0);

    QString downloadUrl((QChar*)iTriggerUrl->Des().Ptr(),iTriggerUrl->Length());

    //uncomment

    Download* download = NULL;//iDlMgr->findDownload( downloadUrl );

    if (download)

        {

        // Stale download found.

        // Remove it, and re-create a new download.

		download->cancel();

		download = NULL;

        if (iFileName)

            {

            iFs.Delete(*iFileName);

            }

        }

    triggerFileName=DRM::CFileNameContainer::NewLC();

#ifndef RD_MULTIPLE_DRIVE

    User::LeaveIfError( roapTrigger.Temp(

                    iFs, KDrmUtilityTriggerFilePath, triggerFileName->iBuffer, EFileWrite ) );

#else //RD_MULTIPLE_DRIVE

    TInt driveNumber(-1);

    TChar driveLetter;

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

    iFs.DriveToChar(driveNumber, driveLetter);

    DRM::CFileNameContainer*

        utilityTriggerFilePath(DRM::CFileNameContainer::NewLC());

    utilityTriggerFilePath->iBuffer.Format(

            KKDrmUtilityTriggerFilePathFormatter, (TUint) driveLetter);

    User::LeaveIfError(roapTrigger.Temp(iFs, utilityTriggerFilePath->iBuffer,

            triggerFileName->iBuffer, EFileWrite));

    CleanupStack::PopAndDestroy( utilityTriggerFilePath );

    utilityTriggerFilePath=NULL;

#endif

    UpdateBufferL<HBufC, TFileName> (iFileName, triggerFileName->iBuffer);

    CleanupStack::PopAndDestroy( triggerFileName );

    triggerFileName=NULL;

    // create and start download

    downloadUrl = ((QChar*)iTriggerUrl->Des().Ptr(),iTriggerUrl->Length());

    iDownload = iDlMgr->createDownload(downloadUrl);

    try

		{

		iDrmUtilityDmgrEventHandler = q_check_ptr(new QDrmUtilityDmgrEventHandler(*this, *iDownload));

		}

    catch(const std::exception& exception)

		{

		qt_symbian_exception2LeaveL(exception);

		}

    iDownloadSuccess = EFalse;

	iConnectionError = EFalse;

	try

		{

		RBuf fileName;

		CleanupClosePushL(fileName);

		roapTrigger.Name(fileName);

		const QVariant& roapTriggerValue( QString((QChar*) fileName.Ptr(), fileName.Length()) );

		CleanupStack::PopAndDestroy(&fileName);

		iDownload->setAttribute(FileName,roapTriggerValue);

		const QVariant& val(ETrue);

		iDownload->setAttribute(ContentType, val);

		iDownload->start();

		}

	catch(const std::exception& exception)

		{

		qt_symbian_exception2LeaveL(exception);

		}

	// wait until download is finished

	iState = aNextState;

	TRequestStatus* status(&iStatus);

	*status = KRequestPending;

	SetActive();

    CleanupStack::PopAndDestroy(&roapTrigger);

    }

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

// CDrmUtilityDmgrWrapper::DoSaveRoapTriggerL

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

//

void CDrmUtilityDmgrWrapper::DoSaveRoapTriggerL(TDownloadState aNextState)

    {

    // Check success of download

    // Fetch download created in DoDownloadRoapTriggerL

	QString downloadUrl((QChar*)iTriggerUrl->Des().Ptr(),iTriggerUrl->Length());

	typedef void (Download::*download_cancel_fnptr) ();

	//uncomment

	Download* dwnld = NULL;//iDlMgr->findDownload( downloadUrl );

	mem_auto_ptr<Download*, download_cancel_fnptr> downloadPtr(dwnld,&WRT::Download::cancel);

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

    // whether or not meteringResponse has PrUrl.

    delete iTriggerUrl;

    iTriggerUrl = NULL;

    iStatus = KRequestPending;

    RFile roapTrigger;