/*

* 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:  User Interactions event handler

*

*/

// INCLUDE FILES

#include    "UserInteractionsEventHandler.h"

#include    "CUserInteractionsUtils.h"

#include    "ProgressInfoCreator.h"

#include    "CDownloadMgrUiLibRegistry.h"

#include    "CDownloadMgrUiDownloadsList.h"

#include    "CDownloadMgrUiUserInteractions.h"

#include    "UiLibLogger.h"

#include    "DMgrUiLibPanic.h"

#include    <bldvariant.hrh>

#include    <DownloadMgrUiLib.rsg>

#include    <aknlists.h>

#include    <aknPopup.h>

#include    <StringLoader.h>

#include    <apgcli.h>

#include    <eikbtgpc.h>

#include    <SysUtil.h>

#include    <exterror.h>

#include    <etelpckt.h>

#include    <AknNoteDialog.h>

#include    <UriUtils.h>

#include    <MGXFileManagerFactory.h>

#include    <CMGXFileManager.h>

#include    <pathinfo.h>

#include    <driveinfo.h>

#include    <apmrec.h>

#include    <apmstd.h>

#include    <s32std.h>

#include    <e32des8.h>

#include    <AiwGenericParam.h>

#include    <DocumentHandler.h>

// LOCAL CONSTANTS AND MACROS

_LIT( KListBoxSeparator, "\t" );

_LIT( KDownloadPath,"download");

const TInt KDownloadConfSizeLimit = 100000;

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

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

// CUserInteractionsEventHandler::CUserInteractionsEventHandler

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

//

CUserInteractionsEventHandler::CUserInteractionsEventHandler

    ( RHttpDownload& aDownload, THttpDownloadEvent aEvent, 

      MDownloadMgrUiLibRegModel& aRegistryModel, 

      CAsyncEventHandlerArray& aOwner,

      CUserInteractionsUtils& aUiUtils )

:   CAsyncEventHandlerBase( aDownload, aEvent, aRegistryModel, aOwner ),

    iUiUtils( aUiUtils ),

    iDownloadConfirmationShown( EFalse )

    {

    CLOG_ENTERFN("CUserInteractionsEventHandler::CUserInteractionsEventHandler");

    CLOG_WRITE_FORMAT(" %x", this);

    CLOG_LEAVEFN("CUserInteractionsEventHandler::CUserInteractionsEventHandler");

    }

// Destructor

CUserInteractionsEventHandler::~CUserInteractionsEventHandler()

    {

    CLOG_ENTERFN("CUserInteractionsEventHandler::~CUserInteractionsEventHandler");

    CLOG_WRITE_FORMAT(" %x", this);

    if ( iPopupList )

        {

        iPopupList->CancelPopup();

        iPopupList = NULL;

        }

    if ( iDeletedPtr )

        {

        *iDeletedPtr = ETrue;

        }

    if ( iDownloadConfirmationDeletedPtr )

        {

        *iDownloadConfirmationDeletedPtr = ETrue;

        }

    Cancel();

    CLOG_LEAVEFN("CUserInteractionsEventHandler::~CUserInteractionsEventHandler");

    }

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

// CUserInteractionsEventHandler::DiskSpaceBelowCriticalLevelL

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

//

#ifdef RD_MULTIPLE_DRIVE

TBool CUserInteractionsEventHandler::DiskSpaceBelowCriticalLevelL( RHttpDownload& aDownload, TInt aSize ) const

#else

TBool CUserInteractionsEventHandler::DiskSpaceBelowCriticalLevelL( TInt aSize ) const

#endif

    {

    CLOG_ENTERFN("CUserInteractionsEventHandler::DiskSpaceBelowCriticalLevelL");

   	TBool isSpaceBelowCL( EFalse );

    RFs fs;

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

    CleanupClosePushL( fs );

    TInt bytesToWrite = aSize;

    if (bytesToWrite < 0)

        bytesToWrite = 0;

#ifdef RD_MULTIPLE_DRIVE

    // Destination is FFS in default

    TInt selectedDrive;

    User::LeaveIfError(

        DriveInfo::GetDefaultDrive( DriveInfo::EDefaultPhoneMemory,

                                    selectedDrive ) );

    TInt err( KErrNone );

    HBufC* fileName = HBufC::NewLC( KMaxPath );

    TPtr fileNamePtr = fileName->Des();

    User::LeaveIfError

        ( aDownload.GetStringAttribute( EDlAttrDestFilename, fileNamePtr ) );

    CLOG_WRITE_FORMAT(" EDlAttrDestFilename: %S",&fileNamePtr);

    // only that drive needs to be checked

    CLOG_WRITE( "cfds1" );

    if( (err = fs.CharToDrive( (*fileName)[0], selectedDrive )) != KErrNone )

        {

        CLOG_WRITE( "Bad drive letter" );

        User::Leave( err );

        }

    else if( !fs.IsValidDrive( selectedDrive ) )

        // invalid drive letter in filename

        {

        CLOG_WRITE( "Invalid drive" );

        User::Leave( KErrBadName );

        }

    CleanupStack::PopAndDestroy( fileName ); // fileName

    fileName = NULL;

    // Check if there's enough memory in the phone

	TRAP_IGNORE( isSpaceBelowCL = SysUtil::DiskSpaceBelowCriticalLevelL(

                                            &fs,

                                            bytesToWrite,

                                            selectedDrive ) );

    // If there is error, then isSpaceBelowCL is untouched and 

    // contains the right value. Otherwise it also contains 

    // the right value.

    CLOG_WRITE_FORMAT(" DiskSpace: isSpaceBelowCL: %d",isSpaceBelowCL);

#else

	isSpaceBelowCL = SysUtil::DiskSpaceBelowCriticalLevelL( &fs, 

			                                bytesToWrite,

                                            EDriveC );

    CLOG_WRITE_FORMAT(" C: isSpaceBelowCL: %d",isSpaceBelowCL);

    if ( isSpaceBelowCL )

        {

        // Check MMC

        TRAP_IGNORE( isSpaceBelowCL = 

                     SysUtil::MMCSpaceBelowCriticalLevelL( &fs, bytesToWrite ) );

        // If there is error, then isSpaceBelowCL is untouched and 

        // contains the right value. Otherwise it also contains 

        // the right value.

        CLOG_WRITE_FORMAT(" MMC: isSpaceBelowCL: %d",isSpaceBelowCL);

        }

#endif

    CleanupStack::PopAndDestroy( &fs ); // fs

    CLOG_LEAVEFN("CUserInteractionsEventHandler::DiskSpaceBelowCriticalLevelL");

    return isSpaceBelowCL;

    }

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

// CUserInteractionsEventHandler::ShowDownloadConfirmationL

// Confirmation is not shown, if:

// - the downloaded size = total size

// - or the total size is less than 100 kB

// The confirmation query is shown, if aForce is ETrue!

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

//

TBool CUserInteractionsEventHandler::ShowDownloadConfirmationL

    ( RHttpDownload& aDownload, TInt aCbaResource, TBool aForce )

    {

    CLOG_ENTERFN("CUserInteractionsEventHandler::ShowDownloadConfirmationL aForce");

    TBool ret;

    if ( aForce )

        {

        ret = ShowDownloadConfirmationL( aDownload, aCbaResource );

        }

    else

        {

        TInt32 totalLength( KErrNotFound );

        TInt32 downloadedSize( KErrNotFound );

        /*

        * Get full size of media content and downloaded size

        */

        User::LeaveIfError( aDownload.GetIntAttribute

                          ( EDlAttrMultipleMOLength, totalLength ) );

        CLOG_WRITE_FORMAT(" EDlAttrMultipleMOLength: %d",totalLength);

        User::LeaveIfError( aDownload.GetIntAttribute

                          ( EDlAttrMultipleMODownloadedSize, downloadedSize ) );

        CLOG_WRITE_FORMAT(" EDlAttrMultipleMODownloadedSizes: %d",downloadedSize);

        HBufC8* contentType = iUiUtils.ContentTypeL( aDownload, ETrue );

        CleanupStack::PushL( contentType );

        // Don't show the confirmation query if the downloading 

        // already finished

        if ( downloadedSize == totalLength )

            {

            ret = ETrue;

            }

        else if ( 0 <= totalLength && totalLength < KDownloadConfSizeLimit )

            {

            ret = ETrue;

            }

        // GGUO-775RXR for widgets we don't need to have download confirmation either             

        else if ( contentType->Compare( KWidgetMimeType) == 0 ) 

            {

            ret = ETrue;                                

            }                                            

        else

            {

            ret = ShowDownloadConfirmationL( aDownload, aCbaResource );

            }

        CleanupStack::PopAndDestroy( contentType );            

        }

    CLOG_LEAVEFN("CUserInteractionsEventHandler::ShowDownloadConfirmationL aForce");

    return ret;

    }

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

// CUserInteractionsEventHandler::ShowDownloadConfirmationL

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

//

// Cod we used the following order

// 		name/size/type/price(optional)/description(no)/vendor(no) 

TBool CUserInteractionsEventHandler::ShowDownloadConfirmationL

    ( RHttpDownload& aDownload, TInt aCbaResource )

    {

    CLOG_ENTERFN("CUserInteractionsEventHandler::ShowDownloadConfirmationL");

    HBufC* itemText = NULL; // a buffer holding the text for each list item

    CEikFormattedCellListBox* listBox = new ( ELeave ) CAknDoublePopupMenuStyleListBox;

    CleanupStack::PushL( listBox );

    // If supported show OK & Cancel buttons, otherwise just CANCEL

    iPopupList = NULL; // reset pointer.

    CAknPopupList* popupList = CAknPopupList::NewL

            ( listBox, aCbaResource, AknPopupLayouts::EMenuDoubleWindow );

    CleanupStack::PushL( popupList );

    TInt flags = CEikListBox::EDisableHighlight;

    listBox->ConstructL( popupList, flags );

    listBox->CreateScrollBarFrameL( ETrue );

    listBox->ScrollBarFrame()->SetScrollBarVisibilityL

        ( CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto );

    MDesCArray* itemList = listBox->Model()->ItemTextArray();

    CDesCArray* itemArray = (CDesCArray*)itemList;

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

    // Header

    //

    HBufC* header = StringLoader::LoadLC( R_DMUL_DOWNLOADCONF_TITLE ); //"Download"

    popupList->SetTitleL( *header );

    CleanupStack::PopAndDestroy( header );  // header

    header = NULL;

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

    // Check the available free space

    //

    TInt32 contentSize( 0 );

    TInt err = aDownload.GetIntAttribute( EDlAttrMultipleMOLength, contentSize );

    if ( err != KErrNone && err != KErrNotFound )

        {

        User::LeaveIfError( err );

        }

    // if size is not known it is set to -1. 0 size content size is ok here.

    TBool isContentSizeKnown = ( err == KErrNone && contentSize > -1 );

#ifdef RD_MULTIPLE_DRIVE

    if ( DiskSpaceBelowCriticalLevelL( aDownload, (TInt)contentSize ) )

#else

    if ( DiskSpaceBelowCriticalLevelL( (TInt)contentSize ) )

#endif

        {

        // Not enough free disk space!

        HBufC* notEnoughSpace = 

            StringLoader::LoadLC( R_DMUL_DOWNLOADCONF_NOT_ENOUGH_MEM );        

        itemArray->AppendL( *notEnoughSpace );

        CleanupStack::PopAndDestroy( notEnoughSpace );  // notEnoughSpace

        // and disable OK button

        popupList->ButtonGroupContainer()->MakeCommandVisible( EAknSoftkeyOk, EFalse );

        }

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

    // Supported?  no need - this was confirmed earlier

    //

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

    // Add name here 

    // name/size/type/price(optional)/description(no)/vendor(no) 

   HBufC* nameHeader = StringLoader::LoadLC( R_DMUL_DOWNLOADCONF_NAME );

   HBufC* dlName = HBufC::NewLC( KMaxPath );            

   TPtr dlNamePtr = dlName->Des();

   User::LeaveIfError( aDownload.GetStringAttribute( EDlAttrName, dlNamePtr ) );

   itemText = FormatListBoxItemLC( *nameHeader, *dlName );

   itemArray->AppendL( *itemText );

   CleanupStack::PopAndDestroy( 3, nameHeader ); // itemText, sizeHeader

   dlName = NULL; 

   itemText = NULL;

   nameHeader = NULL;

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

    // Content Size

    //

    HBufC* sizeHeader = StringLoader::LoadLC( R_DMUL_DOWNLOADCONF_SIZE );

    if ( !isContentSizeKnown )

        {

        HBufC* unknownString = StringLoader::LoadL( R_DMUL_DOWNLOADCONF_UNKNOWN );

        iSizeInfoRes.Copy( unknownString->Left(KMaxDownloadSizeTextLength) );

        delete unknownString;

        }

    else

        {

        CProgressInfoCreator* progInfoCreator = CProgressInfoCreator::NewL();

        progInfoCreator->ProgressInfo( contentSize, iSizeInfoRes );

        delete progInfoCreator;

        progInfoCreator = NULL;

        }

    itemText = FormatListBoxItemLC( *sizeHeader, iSizeInfoRes );

    itemArray->AppendL( *itemText );

    CleanupStack::PopAndDestroy( 2, sizeHeader ); // itemText, sizeHeader

    itemText = NULL;

    sizeHeader = NULL;

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

    // Application Name - only show if Supported

    //  

    HBufC* handlerHeader = StringLoader::LoadLC( R_DMUL_DOWNLOADCONF_OPENWITH );

    RApaLsSession apaLs;

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

    CleanupClosePushL( apaLs );

    TUid appUid;

    HBufC8* contentType = iUiUtils.ContentTypeL( aDownload, ETrue );

    CleanupStack::PushL( contentType );

    #ifdef _DEBUG

    HBufC* contType = HBufC::NewL( contentType->Length() );

    TPtr ptr = contType->Des();

    ptr.Copy( *contentType );

    CLOG_WRITE_FORMAT(" contentType: %S",&ptr);

    delete contType;

    contType = NULL;

    #endif // _DEBUG

    User::LeaveIfError( apaLs.AppForDataType( TDataType(*contentType), appUid ) );

    HBufC* handlerName = ConstructHandlerAppNameLC( appUid, apaLs );

    itemText = FormatListBoxItemLC( *handlerHeader, *handlerName );

    CleanupStack::PopAndDestroy( itemText );

    CleanupStack::PopAndDestroy( handlerName );

    CleanupStack::Pop( contentType ); // Still needed - push later again

    CleanupStack::PopAndDestroy( &apaLs );

    CleanupStack::PopAndDestroy( handlerHeader );

    itemText = NULL;

    handlerName = NULL;

    handlerHeader = NULL;

    CleanupStack::PushL( contentType );

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

    // MIME Content Type

    //

    HBufC* typeHeader = StringLoader::LoadLC( R_DMUL_DOWNLOADCONF_FILETYPE );

    HBufC* typeString = NULL;

    if ( contentType->Length() != 0 )

        {

        // 8 bit -> 16 bit conversion

        typeString = HBufC::NewLC( contentType->Length() );

        typeString->Des().Copy( *contentType );

        }

    else

        {       

        typeString = StringLoader::LoadLC( R_DMUL_DOWNLOADCONF_UNKNOWN );

        }

    itemText = FormatListBoxItemLC( *typeHeader, *typeString );

    itemArray->AppendL( *itemText );

    CleanupStack::PopAndDestroy( 3, typeHeader ); // itemText, typeString , typeHeader

    CleanupStack::PopAndDestroy( contentType );

    itemText = NULL;

    typeString = NULL;

    typeHeader = NULL;

    contentType = NULL;

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

    // Price: since dm has no info, we don't need this at all here 

    //

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

    // Description: since dm has no info, we don't need this at all here 

    //

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

    // Vendor: since dm has no info, we don't need this at all here 

    //

    // Show popup list - it calls CActiveScheduler::Start(), so be careful 

    // when using data members after ExecuteLD!

    iDownloadConfirmationShown = ETrue;

    iPopupList = popupList;

    TBool deleted( EFalse );

    iDownloadConfirmationDeletedPtr = &deleted;

    TInt pressedOk = popupList->ExecuteLD();

    CleanupStack::Pop( popupList );    // popupList 

    if ( !deleted )

        {

        // We can use members only in this case!

        iDownloadConfirmationShown = EFalse;

        iPopupList = NULL;

        }

    // cleanup

    CleanupStack::PopAndDestroy( /*listBox*/ ); // listBox

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

    CLOG_LEAVEFN("CUserInteractionsEventHandler::ShowDownloadConfirmationL");

    return (TBool)pressedOk;

    }

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

// CUserInteractionsEventHandler::ConstructHandlerAppNameLC

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

//

HBufC* CUserInteractionsEventHandler::ConstructHandlerAppNameLC

    ( const TUid& aAppUid, RApaLsSession& aApaLs )

    {

    CLOG_ENTERFN("CUserInteractionsEventHandler::ConstructHandlerAppNameLC");

    HBufC* handlerName = NULL;

    if ( aAppUid == TUid::Null() )

        {

        // No handler found

        handlerName = StringLoader::LoadLC( R_DMUL_DOWNLOADCONF_UNKNOWN );

        }

    else

        {

        TApaAppInfo appInfo;

        User::LeaveIfError( aApaLs.GetAppInfo( appInfo, aAppUid ) );

        CLOG_WRITE_FORMAT(" appInfo.iFullName: %S",&appInfo.iFullName);

        CLOG_WRITE_FORMAT(" appInfo.iCaption: %S",&appInfo.iCaption);

        CLOG_WRITE_FORMAT(" appInfo.iShortCaption: %S",&appInfo.iShortCaption);

        // In many cases there is long caption. We should use short caption only 

        // if it is empty. They say that sometimes the long caption is not empty, 

        // but it contains only a space (0x20). In this case we must use the short.

        // For safety reasons, we will check the whole long caption, if it 

        // contains only space characters.

        const TDesC& longCap = appInfo.iCaption;

        TBool longCapIsEmpty = (longCap.Length() == 0);

        if ( longCapIsEmpty == EFalse )

            {

            TInt longCapLength = longCap.Length();

            TBool containsOnlySpaces = ETrue; // We'll change it, if it's not true.

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

                {

                if ( TChar(longCap[i]).IsSpace() == EFalse )

                    {

                    containsOnlySpaces = EFalse;

                    break;

                    }

                }

            if ( containsOnlySpaces )

                {

                longCapIsEmpty = ETrue;

                }

            }

        if ( longCapIsEmpty )

            {

            // Using short caption

            handlerName = appInfo.iShortCaption.AllocLC();

            }

        else

            {

            // Using long caption

            handlerName = appInfo.iCaption.AllocLC();

            }

        }