/*

* Copyright (c) 2002-2004 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:  Supports user interaction dialogs for downloads

*

*/

// INCLUDE FILES

#include    "CUserInteractionsUtils.h"

#include    "UserInteractionsEventHandler.h"

#include    "AsyncEventHandlerArray.h"

#include    "UiLibLogger.h"

#include    "DMgrUiLibPanic.h"

#include    "MDownloadHandlerObserver.h"

#include    <e32std.h>

#include    <e32def.h>

#include    <StringLoader.h>

#include    <DownloadMgrUiLib.rsg>

#include    <AknQueryDialog.h>

#include    <avkon.rsg>

#include    <eikon.hrh>

#include    <eikappui.h>

#include    <apparc.h>

#include    <AknServerApp.h>

#include    <DRMCommon.h>

// LOCAL CONSTANTS AND MACROS

const TInt KPostponedDownloadsGranularity = 1;

/**

* Extension class.

*/

NONSHARABLE_CLASS( CUserInteractionsExtension ) : public CBase,

                                                  public MDownloadHandlerObserver

    {

    public:  // Constructors and destructor

        /**

        * Two-phased constructor.

        */

        static CUserInteractionsExtension* NewL

             ( CDownloadMgrUiUserInteractions& aUserInteractions );

        /**

        * Destructor.

        */

        virtual ~CUserInteractionsExtension();

    public: // New functions

        /**

        * Postpone handling the given COD download. The download is placed to a 

        * LIFO queue. Call SchedulePostponedDownloadL() to invoke the handling 

        * of a download in the list.

        * @param aDownload The download to be postponed.

        */

        void PostponeCodHandlingL( RHttpDownload& aDownload );

        /**

        * Check if the given download is postponed.

        * @param aDownload The download in question.

        * @return true/false.

        */

        TBool IsPostponed( RHttpDownload& aDownload ) const;

        /**

        * Schedule a postponed download for running.

        */

        void SchedulePostponedDownloadL();

    protected: // Constructors

        /**

        * C++ default constructor.

        */

        CUserInteractionsExtension( CDownloadMgrUiUserInteractions& aUserInteractions );

        /**

        * By default Symbian 2nd phase constructor is private.

        */

        void ConstructL();

    protected: // From MDownloadHandlerObserver

        void NotifyHandlerExit( RHttpDownload* aDownload, TInt aReason );

    public: // Data

        CDownloadMgrUiUserInteractions& iUserInteractions;

        TBuf<KMaxPath> iFileName; ///< Buffer for file name.

        // Attributes

        TBool iIsCompletedStateHandled; ///< Event handling preferencies

        TBool iSuppressDownloadConfirmation;

        CArrayPtrFlat< RHttpDownload >* iPostponedCodDownloads; ///< Owned.

    };

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

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

// CUserInteractionsExtension::CUserInteractionsExtension

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

//

CUserInteractionsExtension::CUserInteractionsExtension

    ( CDownloadMgrUiUserInteractions& aUserInteractions )

:   iUserInteractions( aUserInteractions ), 

    iFileName( KNullDesC ), 

    iIsCompletedStateHandled( ETrue )

    {

    }

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

// CUserInteractionsExtension::ConstructL

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

//

void CUserInteractionsExtension::ConstructL()

    {

    CLOG_ENTERFN("CUserInteractionsExtension::ConstructL");

    CLOG_LEAVEFN("CUserInteractionsExtension::ConstructL");

    }

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

// CUserInteractionsExtension::NewL

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

//

CUserInteractionsExtension* CUserInteractionsExtension::NewL

    ( CDownloadMgrUiUserInteractions& aUserInteractions )

    {

    CUserInteractionsExtension* self = 

        new (ELeave) CUserInteractionsExtension( aUserInteractions );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CUserInteractionsExtension::~CUserInteractionsExtension()

    {

    CLOG_ENTERFN("CUserInteractionsExtension::~CUserInteractionsExtension");

    delete iPostponedCodDownloads;

    CLOG_WRITE(" iPostponedCodDownloads OK");

    CLOG_LEAVEFN("CUserInteractionsExtension::~CUserInteractionsExtension");

    }

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

// CUserInteractionsExtension::PostponeCodHandlingL

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

//

void CUserInteractionsExtension::PostponeCodHandlingL( RHttpDownload& aDownload )

    {

    CLOG_ENTERFN("CUserInteractionsExtension::PostponeCodHandlingL");

    if ( !iPostponedCodDownloads )

        {

        iPostponedCodDownloads = new (ELeave) CArrayPtrFlat< RHttpDownload >

                                            ( KPostponedDownloadsGranularity );

        CLOG_WRITE(" new OK");

        }

    // Insert download at the end of the array

    iPostponedCodDownloads->AppendL( &aDownload );

    CLOG_LEAVEFN("CUserInteractionsExtension::PostponeCodHandlingL");

    }

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

// CUserInteractionsExtension::IsPostponed

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

//

TBool CUserInteractionsExtension::IsPostponed( RHttpDownload& aDownload ) const

    {

    CLOG_ENTERFN("CUserInteractionsExtension::IsPostponed");

    TInt index( KErrNotFound );

    TKeyArrayFix cmpKey( 0, ECmpTUint32 );

    TInt err = KErrNotFound;

    if ( iPostponedCodDownloads )

        {

        err = iPostponedCodDownloads->Find( &aDownload, cmpKey, index );

        CLOG_WRITE_FORMAT(" err: %d", err);

        CLOG_WRITE_FORMAT(" index: %d", index);

        }

    CLOG_LEAVEFN("CUserInteractionsExtension::IsPostponed");

    return !err;

    }

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

// CUserInteractionsExtension::SchedulePostponedDownloadL

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

//

void CUserInteractionsExtension::SchedulePostponedDownloadL()

    {

    CLOG_ENTERFN("CUserInteractionsExtension::SchedulePostponedDownloadL");

    // Start next download handling

    if ( iPostponedCodDownloads )

        {

        TInt postponedCodDlCount = iPostponedCodDownloads->Count();

        CLOG_WRITE_FORMAT(" postponedCodDlCount: %d", postponedCodDlCount);

        if ( postponedCodDlCount )

            {

            // Restart the first COD download in the list

            RHttpDownload* codDl = (RHttpDownload*) iPostponedCodDownloads->At(0);

            TInt errorRet = codDl->Start();

            CLOG_WRITE_FORMAT(" errorRet: %d", errorRet);

            User::LeaveIfError( errorRet );

            // Remove the download from the lifo list, but do not delete it!

            iPostponedCodDownloads->Delete(0);

            }

        }

    CLOG_LEAVEFN("CUserInteractionsExtension::SchedulePostponedDownloadL");

    }

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

// CUserInteractionsExtension::NotifyHandlerExit

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

//

void CUserInteractionsExtension::NotifyHandlerExit( RHttpDownload* aDownload, 

                                                     TInt aReason )

    {

    CLOG_ENTERFN("CUserInteractionsExtension::NotifyHandlerExit");

    CLOG_WRITE_FORMAT(" aReason: %d", aReason);

    // Delete the download if the handler terminated without error

    if ( aReason == KErrNone || aReason == EEikCmdExit || aReason == EAknCmdExit )

        {

        if ( aDownload )

            {

            /* return value is ignored */aDownload->Delete();

            CLOG_WRITE(" Delete OK");

            }

        }

    // Propagate the event to the registered observer, too

    if ( iUserInteractions.iServerAppExitObserver != 0 )

        {

        CLOG_WRITE(" Propagating event...");

        iUserInteractions.iServerAppExitObserver->HandleServerAppExit( aReason );

        }

    CLOG_LEAVEFN("CUserInteractionsExtension::NotifyHandlerExit");

    }

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

// CDownloadMgrUiUserInteractions::CDownloadMgrUiUserInteractions

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

//

CDownloadMgrUiUserInteractions::CDownloadMgrUiUserInteractions

    ( CDownloadMgrUiLibRegistry& aRegistryModel )

:   CDownloadMgrUiBase( aRegistryModel ),

    iDlgActive ( EFalse ),

    iProgressiveDownloadLaunched ( EFalse )

    {

    }

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

// CDownloadMgrUiUserInteractions::ConstructL

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

//

void CDownloadMgrUiUserInteractions::ConstructL()

    {

    CLOG_ENTERFN("CDownloadMgrUiUserInteractions::ConstructL");

    BaseConstructL();

    CLOG_WRITE(" BaseConstructL");

    iExtension = CUserInteractionsExtension::NewL( *this );

    CLOG_WRITE(" iExtension");

    iUiUtils = CUserInteractionsUtils::NewL( *this, iRegistryModel );

    CLOG_WRITE(" iUiUtils");

    iEventHandlerArray = new(ELeave)CAsyncEventHandlerArray();

    CLOG_WRITE(" iEventHandlerArray");

    // Cancel the Soft Notifications belonging to this client

    iUiUtils->CancelSoftNotifStndL

        ( TVwsViewId(iRegistryModel.ClientAppUid(),TUid::Null()), 

          TUid::Null(), KNullDesC8 );

    iUiUtils->CancelSoftNotifEmbL

        ( TVwsViewId(iRegistryModel.ClientAppUid(),TUid::Null()), 

          TUid::Null(), KNullDesC8 );

    CLOG_LEAVEFN("CDownloadMgrUiUserInteractions::ConstructL");

    }

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

// CDownloadMgrUiUserInteractions::NewL

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

//

CDownloadMgrUiUserInteractions* CDownloadMgrUiUserInteractions::NewL

    ( CDownloadMgrUiLibRegistry& aRegistryModel )

    {

    CDownloadMgrUiUserInteractions* self = 

        new ( ELeave ) CDownloadMgrUiUserInteractions( aRegistryModel );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CDownloadMgrUiUserInteractions::~CDownloadMgrUiUserInteractions()

    {

    CLOG_ENTERFN("CDownloadMgrUiUserInteractions::~CDownloadMgrUiUserInteractions");

    delete iEventHandlerArray;

    iEventHandlerArray = 0;

    CLOG_WRITE(" iEventHandlerArray");

    delete iUiUtils;

    iUiUtils = 0;

    CLOG_WRITE(" iUiUtils");

    // iExtension should be the last deleted.

    delete iExtension;

    iExtension = 0;

    CLOG_WRITE(" iExtension");

    CLOG_LEAVEFN("CDownloadMgrUiUserInteractions::~CDownloadMgrUiUserInteractions");

    }

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

// CDownloadMgrUiUserInteractions::OkToExitL

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

//

EXPORT_C 

TBool CDownloadMgrUiUserInteractions::OkToExitL()

    {

    CLOG_ENTERFN("CDownloadMgrUiUserInteractions::OkToExitL");

    TBool okToExit = EFalse;

    TInt downloadCnt = iRegistryModel.DownloadCount();

    CLOG_WRITE_FORMAT(" downloadCnt: %d", downloadCnt);

    // do nothing if this is 0

    if ( downloadCnt == 0 )

        {

        okToExit = ETrue;

        CLOG_LEAVEFN("CDownloadMgrUiUserInteractions::OkToExitL");

        return okToExit;

        }

    // will delete client's completed, not hidden downloads

    THttpDownloadState state;

    THttpProgressState progState;

    TBool isHiddenDel = EFalse;

    TBool isCodDownload( EFalse );

    TBool isProg (EFalse);

    // check if progressive download, if yes, will NOT delete from the list, otherwise will

    const CDownloadArray& downloadsDel = iRegistryModel.DownloadMgr().CurrentDownloads();

    for ( TInt i = downloadCnt - 1; i >= 0; --i )

        {

        RHttpDownload* dl = downloadsDel.At(i); // current download

        dl->GetIntAttribute(EDlAttrState, (TInt32&)state);

         //Changes for the bug JERI-7P8CF2

         //Changes made in the server side to fix the video center receiving unexpected events

         //Reassigning these events back to the changes done in server side

         if( state  == EHttpDlCompleted )

		     {

             state  = EHttpDlMultipleMOCompleted;

		     }

         else if(state  == EHttpDlFailed )

		     {

		      state  = EHttpDlMultipleMOFailed;

		     }

        if ( state == EHttpDlMultipleMOCompleted )

            {

            dl->GetBoolAttribute( EDlAttrHidden, isHiddenDel ); // return value ignored

            dl->GetIntAttribute( EDlAttrProgressState, (TInt32&)progState );

            dl->GetBoolAttribute( EDlAttrProgressive, isProg ); 

            if ( (!isHiddenDel && ( progState == EHttpProgContentFileMoved || progState == EHttpProgContentFileMovedAndDestFNChanged )&& !isProg) )

                {

                User::LeaveIfError( dl->Delete() );

                }

            }

        }

    downloadCnt = iRegistryModel.DownloadCount();

    // Client is intrested in only those downloads for that the 

    // media has not been removed or pausable (non-pausable downloads 

    // will be deleted).

    TInt32 noMediaDownloads(0);

    iRegistryModel.DownloadMgr().GetIntAttribute( EDlMgrNoMediaDls, noMediaDownloads );

    CLOG_WRITE_FORMAT(" noMediaDownloads: %d", noMediaDownloads);

    // Return value is ignored.

    // If it returns an error, then 'noMediaDownloads' is considered 0.

    // Count hidden downloads, too.

    TInt32 hiddenDownloads = 0;

    TBool isHidden;

    const CDownloadArray& downloads = iRegistryModel.DownloadMgr().CurrentDownloads();

    for ( TInt i = 0; i < downloadCnt; ++i )

        {

        RHttpDownload* dl = downloads.At(i); // current download

        dl->GetBoolAttribute( EDlAttrHidden, isHidden ); // return value ignored

        if ( isHidden )

            {

            ++hiddenDownloads;

            }

        }

    CLOG_WRITE_FORMAT(" hiddenDownloads: %d", hiddenDownloads);

    // Check if there is progressively played download

    TInt32 progressivelyPlayed = 0;

    for ( TInt i = downloadCnt - 1; i >=0; --i )

	{

        RHttpDownload* dl = downloads.At(i); //current download

        dl->GetBoolAttribute( EDlAttrProgressive, isProg );

        if (isProg && state==EHttpDlMultipleMOCompleted) 

		{

                progressivelyPlayed++;

                break;

		}

	}

    TBool isPausable; 

    for ( TInt i = 0; i < downloadCnt; ++i )

        {

            RHttpDownload* dl = downloads.At(i);

            dl->GetBoolAttribute( EDlAttrPausable, isPausable );

            if(!isPausable)

            {

                   break;

            }

        }

    downloadCnt = downloadCnt - noMediaDownloads - hiddenDownloads - progressivelyPlayed;

    CLOG_WRITE_FORMAT(" downloads result: %d", downloadCnt);

    if ( downloadCnt < 1 ||  isPausable)

        {

        okToExit = ETrue;

        }

    else

        {

        HBufC* prompt = StringLoader::LoadLC( downloadCnt==1 ? 

                        R_DMUL_EXIT_CONF_SING : R_DMUL_EXIT_CONF_PLUR );

        CAknQueryDialog* conf = CAknQueryDialog::NewL();

        conf->PrepareLC( R_DMUL_EXIT_CONF );

        conf->SetPromptL( *prompt );

        TInt resp = conf->RunLD();

        CleanupStack::PopAndDestroy( prompt ); // prompt

        downloadCnt = iRegistryModel.DownloadCount();

        if ( resp == EAknSoftkeyYes || resp == EAknSoftkeyOk )

		    {

            for ( TInt i = downloadCnt - 1; i >=0; --i )

		        {

	            RHttpDownload* dl = downloads.At(i); //current download

                dl->GetBoolAttribute( EDlAttrPausable , isPausable );

    			    {

                    // Delete not attached downloads.

    	            dl->Delete(); // Return value ignored.

			        }

		        }

            okToExit = ETrue;

    		}

        else

            {

            if ( iRegistryModel.DownloadsListInstalled() )

                {

                // Make visible

                iRegistryModel.DownloadsList().DisplayDownloadsListL();

                }

            }

        }

    CLOG_LEAVEFN("CDownloadMgrUiUserInteractions::OkToExitL");

    return okToExit;

    }

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

// CDownloadMgrUiUserInteractions::PrepareToExit

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

//

EXPORT_C 

TInt CDownloadMgrUiUserInteractions::PrepareToExit( CEikAppUi& aAppUi, 

                                                    TClientAppExitType aExitType, 

                                                    TVwsViewId aViewId, 

                                                    TUid aCustomMessageId, 

                                                    const TDesC8& aViewActivationMsg )

    {

    CLOG_ENTERFN("CDownloadMgrUiUserInteractions::PrepareToExit");

    // send a message to all running PD applications and tell that browser is exiting

    TRAP_IGNORE( iUiUtils->SendMsgTerminateToPdAppsL( iProgressiveDownloadLaunched ));

    TRAPD( err, PrepareToExitL( &aAppUi, aExitType, aViewId, aCustomMessageId, 

                                aViewActivationMsg ) );

	CLOG_WRITE_FORMAT(" err: %d",err);

    CLOG_LEAVEFN("CDownloadMgrUiUserInteractions::PrepareToExit");

    return err;

    }

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

// CDownloadMgrUiUserInteractions::PrepareToExit

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

//

EXPORT_C 

TInt CDownloadMgrUiUserInteractions::PrepareToExit( TUint32 aAppUid,

                                                    TUint32 aViewId, 

                                                    TUint32 aCustomMessageId )

    {

    CLOG_ENTERFN("CDownloadMgrUiUserInteractions::PrepareToExit 2");

    // send a message to all running PD applications and tell that browser is exiting

    TRAP_IGNORE( iUiUtils->SendMsgTerminateToPdAppsL( iProgressiveDownloadLaunched ));

    // Convert parameters to the necessary form

    TVwsViewId viewId( TUid::Uid(aAppUid), TUid::Uid(aViewId) );

    TUid customMessageId( TUid::Uid(aCustomMessageId) );