/*

* 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    "MDownloadHandlerObserver.h"

#include    "CDownloadMgrUiBase.h"

#include    "CDownloadMgrUiLibRegistry.h"

#include    "CDownloadMgrUiDownloadsList.h"

#include    "CDownloadMgrUiUserInteractions.h"

#include    "UiLibLogger.h"

#include    "DMgrUiLibPanic.h"

#include    <DownloadMgrUiLib.rsg>

#include    <DownloadMgrClient.h>

#include    <AiwGenericParam.h>

#include    <DocumentHandler.h>

#include    <coemain.h>

#include    <ErrorUI.h>

#include    <eikenv.h>

#include    <apmstd.h>

#include    <CAknFileSelectionDialog.h>

#include    <CAknMemorySelectionDialog.h>

#include    <AknQueryDialog.h>

#include    <StringLoader.h>

#include    <AknSoftNotificationParameters.h>

#include    <AknSoftNotifier.h>

#include    <AknNoteWrappers.h>

#include    <BrowserDialogsProvider.h>

#include    <HttpDownloadMgrCommon.h>

#include    <PathInfo.h>

#include    <aknglobalnote.h>

#include    <Oma2Agent.h>

#include    <DRMCommon.h>

#include	<apmrec.h>

#include	<apgcli.h>

#include    <s32mem.h>

#include    "bautils.h"

#include	<etelmm.h>

#include	<MmTsy_names.h>

#include    <rconnmon.h>

#include    <DcfEntry.h>

#include    <DcfRep.h>

#include    <MGXFileManagerFactory.h>

#include    <CMGXFileManager.h>

// LOCAL CONSTANTS AND MACROS

const TInt KErrorUiHttpStatusBase = -25000;

const TInt KMinimumSoftNotePriority = 1000;

#define GLOBAL_HTTP_ERROR( err ) ( KErrorUiHttpStatusBase - err )

const TInt FilenameSuffixMaxLength = 16; // Extra space for localization

const TInt FilenameSuffixMaxValue = 9999;// Maximum file number

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

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

// CUserInteractionsUtils::CUserInteractionsUtils

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

//

CUserInteractionsUtils::CUserInteractionsUtils( CDownloadMgrUiBase& aDMgrUiBase, 

                                                MDownloadMgrUiLibRegModel& aRegistryModel )

:   iCoeEnv( *CCoeEnv::Static() ), 

    iDMgrUiBase( aDMgrUiBase ),

    iRegistryModel( aRegistryModel ),

    iDocHandlerUsesTheUi( EFalse )

    {

    }

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

// CUserInteractionsUtils::ConstructL

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

//

void CUserInteractionsUtils::ConstructL()

    {

    CLOG_ENTERFN("CUserInteractionsUtils::ConstructL");

    iDialogsProv = CBrowserDialogsProvider::NewL( 0 );

    CLOG_WRITE(" iDialogsProv OK");

    iSoftNotifier = CAknSoftNotifier::NewL();

    CLOG_WRITE(" iSoftNotifier OK");

    iErrorUi = CErrorUI::NewL();

    iUnderTenFormatter = StringLoader::LoadL( R_QTN_IV_NAME_SUFFIX_UNDER_TEN_FORMATTER );

    iOverTenFormatter = StringLoader::LoadL( R_QTN_IV_NAME_SUFFIX_OVER_TEN_FORMATTER );

    iSearchChar = (*iUnderTenFormatter)[0];

    iCodDownload = EFalse;

    CLOG_LEAVEFN("CUserInteractionsUtils::ConstructL");

    }

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

// CUserInteractionsUtils::NewL

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

//

CUserInteractionsUtils* CUserInteractionsUtils::NewL

( CDownloadMgrUiBase& aDMgrUiBase, MDownloadMgrUiLibRegModel& aRegistryModel )

    {

    CUserInteractionsUtils* self = 

        new ( ELeave ) CUserInteractionsUtils( aDMgrUiBase, aRegistryModel );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CUserInteractionsUtils::~CUserInteractionsUtils()

    {

    CLOG_ENTERFN("CUserInteractionsUtils::~CUserInteractionsUtils");

    // Cancel all executing dialogs/notes/controls

    CancelAllDialogs();

    CLOG_WRITE(" CancelAllDialogs OK");

    delete iDocHandler;

    CLOG_WRITE(" iDocHandler OK");

    delete iSoftNotifier;

    CLOG_WRITE(" iSoftNotifier OK");

    delete iErrorUi;

    CLOG_WRITE(" iErrorUi OK");

    delete iUnderTenFormatter;

    CLOG_WRITE(" iUnderTenFormatter OK");

    delete iOverTenFormatter;

    CLOG_WRITE(" iOverTenFormatter OK");    

    CLOG_LEAVEFN("CUserInteractionsUtils::~CUserInteractionsUtils");

    }

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

// CUserInteractionsUtils::ShowErrorNoteL

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

//

void CUserInteractionsUtils::ShowErrorNoteL( RHttpDownload& aDownload, 

                                             TInt32 aErrorId )

    {

    TInt32 sysErrorId( KErrNone ); // Global (system-wide) error ID

    // DMgr specific error code. See THttpDownloadMgrError.

    // Convert it to Symbian OS system-wide error code.

    switch ( aErrorId )

        {

        case EGeneral:

            {

            // EDlAttrGlobalErrorId gives the system-wide code.

            User::LeaveIfError( aDownload.GetIntAttribute

                              ( EDlAttrGlobalErrorId, sysErrorId ) );

            break;

            }

        case EInternal:

        	{

        	sysErrorId = KErrGeneral;

        	break;

        	}

        case EContentFileIntegrity:

        	{

        	sysErrorId = KErrCorrupt;

        	break;

        	}

        case EDiskFull:

            {

            sysErrorId = KErrDiskFull;

            break;

            }

        case EConnectionFailed:

        case ETransactionFailed:

        case EMoveFailed:

            {

            // EDlAttrGlobalErrorId gives the system-wide code.

            User::LeaveIfError( aDownload.GetIntAttribute

                              ( EDlAttrGlobalErrorId, sysErrorId ) );

            break;

            }

        case EDestFileWriteFailed:

        	{

        	sysErrorId = KErrWrite;

        	break;

        	}

        case EMMCRemoved:

        	{

        	sysErrorId = KErrNotFound;

        	break;

        	}

        case EBadUrl:

        	{

        	sysErrorId = GLOBAL_HTTP_ERROR(414);

        	break;

        	}

        case EWrongDestFilename:

        	{

        	sysErrorId = KErrArgument;

        	break;

        	}

        case EDestFileInUse:

        	{

        	sysErrorId = KErrAccessDenied;

        	break;

        	}

        case EHttpUnhandled:

        	{

            // EDlAttrGlobalErrorId gives the system-wide code.

            User::LeaveIfError( aDownload.GetIntAttribute

                              ( EDlAttrGlobalErrorId, sysErrorId ) );

        	break;

        	}

        // Don't show error notification in the following cases:

        case EHttpAuthenticationFailed:

        case EProxyAuthenticationFailed:

        	{

            sysErrorId = KErrNone;

            break;

        	}

        case EObjectNotFound:

            {

            // Convert to global http error code.

            sysErrorId = GLOBAL_HTTP_ERROR(404);

            break;

            }

        case EPartialContentModified:

        	{

            sysErrorId = GLOBAL_HTTP_ERROR(412);

            break;

        	}

        case EContentExpired:

            {

            sysErrorId = GLOBAL_HTTP_ERROR(205);

            break;

            }

        case EHttpRestartFailed:

            {

            // Show error note by ourself

            HBufC* errorString = 

                   iCoeEnv.AllocReadResourceLC( R_DMUL_ERROR_START_FROM_BEGINNING );

            CAknGlobalNote* globalNote = CAknGlobalNote::NewL();

            CleanupStack::PushL( globalNote );

            globalNote->ShowNoteL( EAknGlobalErrorNote, *errorString );

            CleanupStack::PopAndDestroy( 2, errorString );  // globalNote, errorString

            sysErrorId = KErrNone; // Do not use errorui

            break;

            }

        default:

            {

            sysErrorId = KErrGeneral;

            break;

            }

        }

    if ( sysErrorId != KErrNone )

        {

        if ( sysErrorId == KErrHttpPartialResponseReceived )

            { // FMLK-72653Y : as server closed connection unexpectedly,  

              // and there is no good error note, use KErrDisconnected instead.

            iErrorUi->ShowGlobalErrorNoteL( KErrDisconnected, CTextResolver::ECtxAutomatic );

            }

        else

            {

            iErrorUi->ShowGlobalErrorNoteL( sysErrorId, CTextResolver::ECtxAutomatic );

            }

        }

    }

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

// CUserInteractionsUtils::ShowErrorNoteL

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

//

void CUserInteractionsUtils::ShowErrorNoteL( TInt aErrorId )

    {

    iErrorUi->ShowGlobalErrorNoteL( aErrorId, CTextResolver::ECtxAutomatic );

    }

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

// CUserInteractionsUtils::IsRecoverableFailL

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

//

TBool CUserInteractionsUtils::IsRecoverableFailL( RHttpDownload& aDownload, 

                                                  TInt32 aErrorId ) const

    {

    TBool recoverable( ETrue );

    // What is the error?

    TInt32 errorId( aErrorId ); // DMgr specific error ID

    CLOG_WRITE_FORMAT("Fail reason: %d", errorId);

    //

    // EDlAttrGlobalErrorId gives the system-wide code.

    TInt32 sysErrorId( 0 );

    User::LeaveIfError( aDownload.GetIntAttribute

                      ( EDlAttrGlobalErrorId, sysErrorId ) );

    TBool pausable( ETrue );

    User::LeaveIfError( aDownload.GetBoolAttribute( EDlAttrPausable, pausable ) );

    if ( errorId == EObjectNotFound )

         // Other error situations can be added to the list. //

        {

        recoverable = EFalse;

        }

    else if ( errorId == ETransactionFailed )

        {        

        if ( sysErrorId == KBadMimeType || sysErrorId == -20000 || sysErrorId == KErrHttpPartialResponseReceived || !pausable )

        // KBadMimeType and -20000 is from DRMFilter

        // Transaction must be cancelled and download must be deleted

            {

            recoverable = EFalse;

            }

        else

            {

            recoverable = ETrue;

            }

        }

    else if ( errorId == EGeneral )

        {

        if ( sysErrorId == KErrNoMemory || sysErrorId == KErrDiskFull )

        //Memory full or Disk Full can be Recoverable error if Download is Pausable    

            {

            recoverable = pausable;

            }

        else 

            {

            recoverable = EFalse;

            }

        }

    else

        {

        recoverable = EFalse;

        }

    CLOG_WRITE_FORMAT("IsRecoverableFailL: %d", (TInt)recoverable);

    return recoverable;

    }

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

// CUserInteractionsUtils::HandleContentL

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

//

void CUserInteractionsUtils::HandleContentL

( RHttpDownload& aDownload, MDownloadHandlerObserver& aHandlerObserver )

    {

    CLOG_ENTERFN("CUserInteractionsUtils::HandleContentL");

    __ASSERT_DEBUG( !iRegistryModel.UserInteractions().IsUiBusy(), 

                    Panic( EUiLibPanDocHandlerAlreadyRunning ) );

    if ( iRegistryModel.UserInteractions().IsUiBusy() )

        {

        CLOG_WRITE(" IsUiBusy() true");

        }

    else

        {

        iHandledDownload = &aDownload;

        iHandlerObserver = &aHandlerObserver;

        // BEGIN: Get attributes for generic params 

        //=========================

        //   EDlAttrCurrentUrl

        //=========================

        HBufC* url = HBufC::NewLC( KMaxUrlLength );

        TPtr urlPtr = url->Des();

        User::LeaveIfError

            ( aDownload.GetStringAttribute( EDlAttrCurrentUrl, urlPtr ) );

        CLOG_WRITE_FORMAT(" EDlAttrCurrentUrl: %S",url);

        //=========================

        //   EDlAttrDestFilename

        //=========================

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

        TPtr fileNamePtr = fileName->Des();

        TInt32 numMediaObjects = 0;

        User::LeaveIfError( aDownload.GetIntAttribute( EDlAttrNumMediaObjects, numMediaObjects ) );

        if (numMediaObjects > KFirstMoIndex)

            {

            User::LeaveIfError

                ( aDownload.GetStringAttribute( EDlAttrDestFilename, KFirstMoIndex, fileNamePtr ) );

            }

        else

            {

            User::LeaveIfError

                ( aDownload.GetStringAttribute( EDlAttrDestFilename, fileNamePtr ) );

            }

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

        // check if file exists, if does not , don't continue

        if ( !IsDuplicateL( fileNamePtr ) )

            {

            HBufC* infoPrompt = StringLoader::LoadLC( R_DMUL_ERROR_FILE_NOT_FOUND);

            CAknInformationNote* note = new(ELeave)  CAknInformationNote();

            note->ExecuteLD(*infoPrompt);

            CleanupStack::PopAndDestroy(infoPrompt);	

            CleanupStack::PopAndDestroy( fileName ); // fileName

            CleanupStack::PopAndDestroy( url ); // url            

            return;

            }

        //=========================

        //   EDlAttrContentType

        //=========================

        HBufC8* contentType = ContentTypeL(aDownload, ETrue, KFirstMoIndex);

        //=========================

        //   EDlMgrIap

        //=========================

        TInt32 iap;

        User::LeaveIfError

            ( iRegistryModel.DownloadMgr().GetIntAttribute( EDlMgrIap, iap ) );

        CLOG_WRITE_FORMAT(" EDlMgrIap: %d",iap);

        //=========================

        //   EDlAttrCharSet

        //=========================

        HBufC* charset = HBufC::NewLC( KMaxDefAttrLength );

        TPtr charsetPtr = charset->Des();

        TInt retVal = aDownload.GetStringAttribute( EDlAttrCharSet, charsetPtr );

        CLOG_WRITE_FORMAT(" EDlAttrCharSet retVal: %d",retVal);

        if( ( KErrNotFound == retVal ) || ( KErrNone == retVal ) )

            {

            // The Char Set is either found or not found but we don't care!!!

            CLOG_WRITE_FORMAT(" EDlAttrCharSet: %S",charset);

            }

        else

            {

            User::Leave( retVal );

            }

        //=========================

        //   EDlAttrRequestReferer

        //=========================

        HBufC* refererUri = HBufC::NewLC( KMaxUrlLength );

        TPtr refererUriPtr = refererUri->Des();

        retVal = aDownload.GetStringAttribute( EDlAttrRequestReferer, refererUriPtr );

        CLOG_WRITE_FORMAT(" EDlAttrRequestReferer retVal: %d",retVal);

        if( ( KErrNotFound == retVal ) || ( KErrNone == retVal ) )

            {

            // The Char Set is either found or not found but we don't care!!!

            CLOG_WRITE_FORMAT(" refererUri: %S",refererUri);

            }

        else

            {

            User::Leave( retVal );

            }

        // END: Get attributes for generic params 

        //Creating generic param list

        CAiwGenericParamList* genericParamList = CAiwGenericParamList::NewLC();

        TAiwVariant iapVariant( iap );

        TAiwGenericParam genericParamIap( EGenericParamAccessPoint, iapVariant );

        genericParamList->AppendL( genericParamIap );

        if( url->Length() )

            {

            TAiwVariant urlVariant( *url );

            TAiwGenericParam genericParamUrl( EGenericParamURL, urlVariant );

            genericParamList->AppendL( genericParamUrl );

            }

        if( charset->Length() )

            {

            TAiwVariant charSetVariant( *charset );

            TAiwGenericParam genericParamCharSet

                ( EGenericParamCharSet, charSetVariant );

            genericParamList->AppendL( genericParamCharSet );

            }

        if( refererUri->Length() )

            {

            TAiwVariant refUriVariant( *refererUri );

            TAiwGenericParam genericParamRefUri

                ( EGenericParamReferringURI, refUriVariant );

            genericParamList->AppendL( genericParamRefUri );

            }

        if( fileName->Length() )

            {

            TAiwVariant fileNameVariant( *fileName );

            TAiwGenericParam genericParamFileName

                ( EGenericParamFile, fileNameVariant );

            genericParamList->AppendL( genericParamFileName );

            }

        CLOG_WRITE_FORMAT(" iDocHandler: %x",iDocHandler);

    	delete iDocHandler;

    	iDocHandler = 0;

        iDocHandler = CDocumentHandler::NewL();

        iDocHandler->SetExitObserver( this );

        RFile file;

        iDocHandler->OpenTempFileL( *fileName, file );

        CleanupClosePushL( file );

        TDataType dataType( *contentType );

        TInt docErr( KErrNone );

        TInt trappedError( KErrNone );

        iDocHandlerUsesTheUi = ETrue;

        TRAP( trappedError, 

              docErr = iDocHandler->OpenFileEmbeddedL( file, 

                                                       dataType, 

                                                       *genericParamList ) );

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

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

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

        CLOG_WRITE(" PopAndDestroy file OK");

        if ( trappedError || docErr )

            {

            delete iDocHandler;

    	    iDocHandler = 0;

    	    iDocHandlerUsesTheUi = EFalse;

    	    // Since we know this is an open file error, we should handle it by calling 

    	    // ShowErrorNotesL instead of propagating the error 

            if ( trappedError ) 

                {

                ShowErrorNoteL (aDownload, trappedError );

                }

            else 

                {

                ShowErrorNoteL (aDownload, docErr );

                }            

            }

        CleanupStack::PopAndDestroy( genericParamList ); // genericParamList