/*

* Copyright (c) 2008 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: 

*

*/

// INCLUDE FILES

#include <mpxlog.h>

#include <utf.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediageneraldefs.h>

#include <mpxcollectionpluginobserver.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include "vcxmyvideosdownloadutil.h" //this has to be before vcxconnectionutility.h

#include <ipvideo/vcxconnectionutility.h>

#include <vcxmyvideosdefs.h>

#include <vcxmyvideosuids.h>

#include <mpxmediageneraldefs.h>

#include <MediatorEventProvider.h>

#include <centralrepository.h>

#include <bautils.h>

#include "vcxmyvideosdrivemonitor.h"

// CONSTANTS

#ifdef _DEBUG

_LIT(KVcxHttpDlCreatedDes, "DlCreated");

_LIT(KVcxHttpDlInprogressDes, "DlInprogress");

_LIT(KVcxHttpDlPausedDes, "DlPaused");

_LIT(KVcxHttpDlCompletedDes, "DlCompleted");

_LIT(KVcxHttpDlFailedDes, "DlFailed");

_LIT(KVcxHttpDlMovedDes, "DlMoved");

_LIT(KVcxHttpDlMediaRemovedDes, "DlMediaRemoved");

_LIT(KVcxHttpDlMediaInsertedDes, "DlMediaInserted");

_LIT(KVcxHttpDlPausableDes, "DlPausable");

_LIT(KVcxHttpDlNonPausableDes, "DlNonPausable");

_LIT(KVcxHttpDlDeletedDes, "DlDeleted");

_LIT(KVcxHttpDlAlreadyRunningDes, "DlAlreadyRunning");

_LIT(KVcxHttpDlDeletingDes, "DlDeleting");

_LIT(KVcxHttpDlMultipleMOStartedDes, "DlMultipleMOStarted");

_LIT(KVcxHttpDlMultipleMOCompletedDes, "DlMultipleMOCompleted");

_LIT(KVcxHttpDlMultipleMOFailedDes, "DlMultipleMOFailed");

_LIT(KVcxUnknownStateDes, "UnknownStateDes");

_LIT(KVcxHttpProgNoneDes, "ProgNone");

_LIT(KVcxHttpStartedDes, "Started");

_LIT(KVcxHttpProgCreatingConnectionDes, "ProgCreatingConnection");

_LIT(KVcxHttpProgConnectionNeededDes, "ProgConnectionNeeded");

_LIT(KVcxHttpProgConnectedDes, "ProgConnected");

_LIT(KVcxHttpProgConnectionSuspendedDes, "ProgConnectionSuspended");

_LIT(KVcxHttpProgDisconnectedDes, "ProgDisconnected");

_LIT(KVcxHttpProgDownloadStartedDes, "ProgDownloadStarted");

_LIT(KVcxHttpContentTypeRequestedDes, "ContentTypeRequested");

_LIT(KVcxHttpContentTypeReceivedDes, "ContentTypeReceived");

_LIT(KVcxHttpProgSubmitIssuedDes, "ProgSubmitIssued");

_LIT(KVcxHttpProgResponseHeaderReceivedDes, "ProgResponseHeaderReceived");

_LIT(KVcxHttpProgResponseBodyReceivedDes, "ProgResponseBodyReceived");

_LIT(KVcxHttpProgRedirectedPermanentlyDes, "ProgRedirectedPermanently");

_LIT(KVcxHttpProgRedirectedTemporarilyDes, "ProgRedirectedTemporarily");

_LIT(KVcxHttpProgDlNameChangedDes, "ProgDlNameChanged");

_LIT(KVcxHttpProgContentTypeChangedDes, "ProgContentTypeChanged");

_LIT(KVcxHttpProgCodDescriptorDownloadedDes, "ProgCodDescriptorDownloaded");

_LIT(KVcxHttpProgCodDownloadStartedDes, "ProgCodDownloadStarted");

_LIT(KVcxHttpProgCodDescriptorAcceptedDes, "ProgCodDescriptorAccepted");

_LIT(KVcxHttpProgCodLoadEndDes, "ProgCodLoadEnd");

_LIT(KVcxHttpProgSupportedMultiPartDes, "ProgSupportedMultiPart");

_LIT(KVcxHttpProgMovingContentFileDes, "ProgMovingContentFile");

_LIT(KVcxHttpProgContentFileMovedDes, "ProgContentFileMoved");

_LIT(KVcxUnknownProgressDes, "UnknownProgress");

#endif

const TInt KMaxPathLength = 255;

_LIT( KVcxExtensionDcf, ".dcf" );

_LIT( KVcxExtensionOcf, ".odf" );

_LIT( KVcxExtensionDm, ".dm" );

_LIT( KVcxExtensionMp4, ".mp4" );

_LIT( KVcxExtensionMpeg4, ".mpeg4" );

_LIT( KVcxExtensionM4v, ".m4v" );

_LIT( KVcxExtension3gpp, ".3gpp" );

_LIT( KVcxExtension3gp, ".3gp" );

_LIT( KVcxExtensionRm, ".rm" );

_LIT( KVcxExtensionMpg4, ".mpg4" );

_LIT( KVcxExtensionRmvb, ".rmvb" );

_LIT( KVcxExtension3g2, ".3g2" );

_LIT( KVcxExtensionWmv, ".wmv" );

_LIT( KVcxExtensionAsf, ".asf" );

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

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

// Two-phased constructor.

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

//

CVcxMyVideosDownloadUtil* CVcxMyVideosDownloadUtil::NewL(

    MVcxMyVideosDownloadUtilObserver& aObserver, RFs& aFs )

    {

    MPX_FUNC("CVcxMyVideosDownloadUtil::NewL");

    CVcxMyVideosDownloadUtil* self = new (ELeave) CVcxMyVideosDownloadUtil( aObserver, aFs );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// Destructor.

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

//

CVcxMyVideosDownloadUtil::~CVcxMyVideosDownloadUtil()

    {

    MPX_FUNC("CVcxMyVideosDownloadUtil::~CVcxMyVideosDownloadUtil");

    iDownloadManager.Disconnect(); //disconnects all downloads and puts them to pause

    iDownloadManager.Close();

    delete iDownloadDeleteTimer;

    iDownloadsToDelete.Close();

    iDeleteContent.Close();

    if ( iConnUtil )

        {

        iConnUtil->RemoveObserver( this );

        iConnUtil->DecreaseReferenceCount();

        }

    delete iMediatorEventProvider;

    delete iDownloadProgressTimer;

    }

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

// Constructor.

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

//

CVcxMyVideosDownloadUtil::CVcxMyVideosDownloadUtil(

        MVcxMyVideosDownloadUtilObserver& aObserver, RFs& aFs )

: iObserver( aObserver ), iFs( aFs )

    {

    MPX_FUNC("CVcxMyVideosDownloadUtil::CVcxMyVideosDownloadUtil");

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CVcxMyVideosDownloadUtil::ConstructL ()

    {

    MPX_FUNC("CVcxMyVideosDownloadUtil::ConstructL");

    TUid uid = TUid::Uid( KVcxUidMyVideosMpxCollection );

    iDownloadManager.ConnectL( uid, *this, ETrue );

    iDownloadDeleteTimer = CVcxMyVideosTimer::NewL( 0, *this );

    iDownloadProgressTimer = CVcxMyVideosTimer::NewL( 0, *this );

    iDownloadsToDelete.Reset();

    iDeleteContent.Reset();

    iConnUtil = CVcxConnectionUtility::InstanceL();

    iConnUtil->RegisterObserverL( this ); 

    iMediatorEventProvider = CMediatorEventProvider::NewL();

    }

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

// CVcxMyVideosDownloadUtil::StartDownloadL

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

//

void CVcxMyVideosDownloadUtil::StartDownloadL( CMPXMedia& aDownload )

    {

    MPX_FUNC("CVcxMyVideosDownloadUtil::StartDownloadL");

    // Requesting a new connection, update state

    iRoamingOngoing = EFalse;

    TInt err( KErrNone );

    TUint32 iap( 0 );

    iap = *(aDownload.Value<TUint>( KVcxMediaMyVideosIapId ));

    if( !iap )

        {

        // no iap gotten yet. Use connectionutility to get one

        err = iConnUtil->GetIap( iap, EFalse );

        if( err != KErrNone || iap == 0 )

            {

            MPX_DEBUG2("CVcxMyVideosDownloadUtil:: failed to get IAP from connectionutility: %d", err);

            User::Leave( KErrCancel );

            }        

        }

    //if not set, the default is used from commsdb

    if ( iap != iCurrentIap )

        {

        err = iDownloadManager.SetIntAttribute( EDlMgrIap, iap );

        }

    iCurrentIap = iap;

    if ( err != KErrNone )

        {

        MPX_DEBUG2("CVcxMyVideosDownloadUtil:: failed to set IAP: %d", err);

        }

    TMPXItemId mpxId = aDownload.ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );

    MPX_DEBUG2( "URL      = %S", &(aDownload.ValueText( KVcxMediaMyVideosRemoteUrl )) );

    MPX_DEBUG2( "Username = %S", &(aDownload.ValueText( KVcxMediaMyVideosUsername )) );

    MPX_DEBUG2( "Password = %S", &(aDownload.ValueText( KVcxMediaMyVideosPassword )) );

    MPX_DEBUG2( "Filename = %S", &(aDownload.ValueText( KMPXMediaGeneralUri )) );

    MPX_DEBUG2( "IAP ID   = %d", *(aDownload.Value<TUint>( KVcxMediaMyVideosIapId )) );

    MPX_DEBUG2( "MDS ID   = %d", mpxId.iId1 );

    iUrl.Copy( aDownload.ValueText( KVcxMediaMyVideosRemoteUrl ) );

    TInt32 downloadId = 0;

    // try to get download id from the download request

    if ( aDownload.IsSupported(KVcxMediaMyVideosDownloadId) )

        {

        MPX_DEBUG1("CVcxMyVideosDownloadUtil:: dl id is supported");

        downloadId = static_cast<TInt32>(

            aDownload.ValueTObjectL<TUint32>( KVcxMediaMyVideosDownloadId ));

        if ( downloadId != 0 )

            {

            MPX_DEBUG1("CVcxMyVideosDownloadUtil:: dl id found -> resuming download");

            } 

        }

    if ( downloadId == 0 )

        {

        MPX_DEBUG1("CVcxMyVideosDownloadUtil:: creating download");

        RHttpDownload& dl =  iDownloadManager.CreateDownloadL( iUrl );

        dl.GetIntAttribute( EDlAttrId, downloadId );

        }

    RHttpDownload* download = Download( downloadId );

    if ( !download )

        {

        MPX_DEBUG1("CVcxMyVideosDownloadUtil:: no download found");

        User::Leave( KErrNotFound );

        }

    CnvUtfConverter::ConvertFromUnicodeToUtf8(iUserName,

            aDownload.ValueText( KVcxMediaMyVideosUsername ) );

    CnvUtfConverter::ConvertFromUnicodeToUtf8(iPassword,

            aDownload.ValueText( KVcxMediaMyVideosPassword ) );    

    download->SetStringAttribute( EDlAttrDestFilename,

            aDownload.ValueText( KMPXMediaGeneralUri ) );        

    download->SetStringAttribute( EDlAttrUsername, iUserName );

    download->SetStringAttribute( EDlAttrPassword, iPassword );

    download->SetBoolAttribute( EDlAttrSilent, EFalse) ;

    download->SetBoolAttribute( EDlAttrNoContentTypeCheck, ETrue );

    err = download->Start();

    if ( err != KErrNone )

        {

        MPX_DEBUG2("CVcxMyVideosDownloadUtil:: could not start download: %d", err);

        }

    aDownload.SetTObjectValueL<TUint32>( KVcxMediaMyVideosDownloadId, downloadId );

    if( !err )

        {

        NotifyDownloadStarted();

        StartProgressTimer();

        }

    }

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

// CVcxMyVideosDownloadUtil::PauseDownload

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

//

TInt CVcxMyVideosDownloadUtil::PauseDownload( TUint32 aDownloadId )

    {

    RHttpDownload* download = Download( aDownloadId );

    if ( !download )

        {

        MPX_DEBUG1("CVcxMyVideosDownloadUtil:: no download found");

        return KErrNotFound;

        }

    return download->Pause();    

    }

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

// CVcxMyVideosDownloadUtil::HandleDMgrEventL

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

//

void CVcxMyVideosDownloadUtil::HandleDMgrEventL( RHttpDownload& aDownload,

    THttpDownloadEvent aEvent )

    {

    MPX_FUNC("CVcxMyVideosDownloadUtil::HandleDMgrEventL");

    TInt32 downloadId;

    aDownload.GetIntAttribute( EDlAttrId, downloadId );

#ifdef _DEBUG

    MPX_DEBUG4("CVcxMyVideosDownloadUtil::HandleDMgrEventL(DL ID: %d, %S, %S)",

            downloadId,

            &GetS60DlProgressDes(aEvent.iProgressState),

            &GetS60DlStateDes(aEvent.iDownloadState));

    if ( aEvent.iProgressState == EHttpContentTypeReceived )

        {

        const TInt debugBufMaxSize = 255;

        TBuf<debugBufMaxSize> contentType;

        aDownload.GetStringAttribute( EDlAttrContentType, contentType );

        MPX_DEBUG2("CVcxMyVideosDownloadUtil:: Content type = %S", &contentType);

        }

#endif

    TInt8 progress( 0 );

    TUint64 downloaded( 0 );

    TInt32 remoteFileSize;

    aDownload.GetIntAttribute( EDlAttrLength, remoteFileSize );

    if ( remoteFileSize > 0 )

        {

        TBool silent;

        aDownload.GetBoolAttribute( EDlAttrSilent, silent );

        TBool progressive;

        aDownload.GetBoolAttribute( EDlAttrProgressive, progressive );        

        if ( !silent && !progressive )

            {

            // remote file size received, we can set download to silent mode.

            MPX_DEBUG2("CVcxMyVideosDownloadUtil:: setting download %d to silent mode", downloadId);

            aDownload.SetBoolAttribute( EDlAttrSilent, ETrue );

            }

        if ( silent && progressive )

            {

            aDownload.SetBoolAttribute( EDlAttrSilent, EFalse );

            }

        progress = DownloadProgress( aDownload, downloaded, EFalse );

        }

    TVcxMyVideosDownloadState state;

    switch ( aEvent.iDownloadState )

        {

        case EHttpDlPaused:

            {

            state = EVcxMyVideosDlStatePaused;

            iObserver.HandleDlEvent( state, static_cast<TUint32>(downloadId),

                    progress, downloaded, 0, 0 );

            NotifyIfNoActiveDownloads();

            StopProgressTimer();

            }

            break;

        case EHttpDlCompleted:

        case EHttpDlMultipleMOCompleted:

            state = EVcxMyVideosDlStateDownloaded;

            iObserver.HandleDlEvent(

                    state, static_cast<TUint32>(downloadId), progress, downloaded, 0, 0 );

            DeleteDownloadAsync( downloadId, EFalse /* dont delete content */ );

            StopProgressTimer();

            break;

        case EHttpDlFailed:

        case EHttpDlMultipleMOFailed:

            {

            TInt32 errorId;

            TInt32 globalErrorId;

            aDownload.GetIntAttribute( EDlAttrErrorId, errorId );

            aDownload.GetIntAttribute( EDlAttrGlobalErrorId, globalErrorId );

            MPX_DEBUG2("CVcxMyVideosDownloadUtil:: DL error ID: %d", errorId);

            MPX_DEBUG2("CVcxMyVideosDownloadUtil:: DL global error ID: %d", globalErrorId);

            state = EVcxMyVideosDlStateFailed;

            iObserver.HandleDlEvent(

                    state,

                    static_cast<TUint32>(downloadId),

                    progress,

                    downloaded,

                    errorId,

                    globalErrorId );

            NotifyIfNoActiveDownloads();

            StopProgressTimer();

            }

            break;

        case EHttpDlCreated:            

        case EHttpDlInprogress:           

        case EHttpDlMultipleMOStarted:

            iObserver.HandleDlEvent( EVcxMyVideosDlStateDownloading,

                    static_cast<TUint32>(downloadId), progress, downloaded, 0, 0 );

            StartProgressTimer();

            break;       

        /// Download is going to be deleted. Cancel or download complete will trigger this.

        case EHttpDlDeleting:

        /// Download is deleted from another client instance. Normally not received, included here just to be sure.

        case EHttpDlDeleted:

            {

            NotifyIfNoActiveDownloads();

            StopProgressTimer();

            }

            break;

        /// download is moved from one client instance to another one.

        case EHttpDlMoved:

        /// MMC card or other storage media is removed from the phone.

        case EHttpDlMediaRemoved:

        /** MMC card or other storage media inserted and 

        * downloaded content file found on it. 

        * If MMC card inserted, but (partially) downloaded content file 

        * is not found on it, download is failed with error reason

        * EContentFileIntegrity. */

        case EHttpDlMediaInserted:

        /** Download process can be paused again. This event only occurs after

        * EHttpDlNonPausable. */

        case EHttpDlPausable:

        /// Download process cannot be paused, or the content will be lost.

        case EHttpDlNonPausable:

        /// Download is started when it's already progressing

        case EHttpDlAlreadyRunning:

        /// Internally used download event. Do NOT deal with them

        case EHttpDlCancelTransaction:

        default:

            break;

        }

    }

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

// CVcxMyVideosDownloadUtil::Download

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

//        

RHttpDownload* CVcxMyVideosDownloadUtil::Download( TUint32 aDownloadId )

    {

    if ( aDownloadId == 0 )

        {

        return NULL;

        }

    TInt count = iDownloadManager.CurrentDownloads().Count();

    TInt i;

    TInt32 downloadId;

    for ( i = 0; i < count; i++ )

        {

        iDownloadManager.CurrentDownloads()[i]->GetIntAttribute( EDlAttrId, downloadId );

        if ( downloadId == aDownloadId )

            {

            return iDownloadManager.CurrentDownloads()[i];

            }

        }

    MPX_DEBUG2("CVcxMyVideosDownloadUtil:: no download found with %d ID", aDownloadId);        

    return NULL;

    }

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

// CVcxMyVideosDownloadUtil::Download

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

//        

RHttpDownload* CVcxMyVideosDownloadUtil::Download( const TDesC& aFileName )

    {    

    MPX_FUNC("CVcxMyVideosDownloadUtil::Download()");

    TInt count = iDownloadManager.CurrentDownloads().Count();

    TInt i;

    for ( i = 0; i < count; i++ )

        {

        const TInt KMaxFileNameLength = 256;

        TBuf<KMaxFileNameLength> fileName;

        iDownloadManager.CurrentDownloads()[i]->GetStringAttribute( EDlAttrDestFilename, fileName );

        MPX_DEBUG3("CVcxMyVideosDownloadUtil:: download[%d] filename = %S", i, &fileName);        

        if ( aFileName == fileName )

            {

            return iDownloadManager.CurrentDownloads()[i];

            }

        }

    MPX_DEBUG2("CVcxMyVideosDownloadUtil:: no download found with %S filename", &aFileName);        

    return NULL;

    }

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

// CVcxMyVideosDownloadUtil::Downloads

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

//        

const CDownloadArray& CVcxMyVideosDownloadUtil::Downloads()

    {    

    return iDownloadManager.CurrentDownloads();

    }

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

// CVcxMyVideosDownloadUtil::CancelDownload

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

//

TInt CVcxMyVideosDownloadUtil::CancelDownload( TInt32 aId, TBool aDeleteContent )

    {

    MPX_FUNC("CVcxMyVideosDownloadUtil::CancelDownload");

    if ( iDownloadManager.CurrentDownloads().Count() < 1 )