/*

* Copyright (c) 2002 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:  Implementation of the CBrowserDialogsProvider class.

*

*/

// INCLUDE Files

// User includes

#include <browserdialogsprovider.h>	// Class header

#include "BrowserDialogsProvider.hrh"

#include "BrowserAuthenticationDialog.h"

#include "BrowserDialogsProviderConstants.h"

#include <browserdialogsproviderobserver.h> //obs

// Browser as a Plugin - own classes

#include "BrowserViewImagesPopup.h"		// For DialogDisplayPageImagesL

#include "BrowserScriptPromptDialog.h"	// For DialogPromptLC

#include "BrowserSelectElementDlg.h"	// For DialogFileSelectLC

#include "BrowserUploadProgressNote.h"  // For UploadProgressNoteL

// System Includes

#include <aknLists.h>					// for Object Element Dialog

#include <aknmessagequerydialog.h>		// DialogAlertL

#include <CAknFileSelectionDialog.h>	// File Selection Dialog

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#include <CAknMemorySelectionDialogMultiDrive.h>

#include <AknCommonDialogsDynMem.h>

#else

#include <CAknMemorySelectionDialog.h>

#include <AknCommonDialogs.h>			// File Selection Dialog

#endif

#include <aknnotewrappers.h>			

#include <AknInfoPopupNoteController.h> // tooltip

#include <PathConfiguration.hrh>

#include <FeatMgr.h>

#include <MGFetch.h> // Media Fetch

// General

#include <StringLoader.h>				// strings

#include <f32file.h>

#include <THttpFields.h>

#include <textresolver.h>

// Resources

#include <coneresloader.h>

#include <BrowserDialogsProvider.rsg>

// Data Caging

#include <data_caging_path_literals.hrh>

// CONSTANTS

const TInt KBrCtlObjectElementMaxLength = 50;

const TInt KBrCtlMBFormat = 4;

const TInt KBrCtlGBFormat = 10;

const TInt KBrCtlMegabyte = 1000;	// although 1MB=1024 kB, treat as 1000kb for user simplicity

const TInt KBrowserFileNotFound  = -26003; // Defined in ErrorDefs.h but not exported so define here

//There is an empty note popup is displayed because of this undefined error code that has been thrown by http layer

const TInt KHttpErrIgnore  = -26173;

// DLL resource file name with path

_LIT( KBrowserDialogsProviderDirAndFile, "z:BrowserDialogsProvider.rsc" );// resource

//Mime Types

_LIT( KMimeTypeImage, "image/*" );

_LIT( KMimeTypeAudio, "audio/*" );

_LIT( KMimeTypeVideo, "video/*" );

// MACROS

#define JAPANESE ( FeatureManager::FeatureSupported( KFeatureIdJapanese ) )

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

/*

*/

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

CBrowserDialogsProvider::CBrowserDialogsProvider( 

								MBrowserDialogsProviderObserver* aObserver )

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

    iObserver( aObserver ),

    iResourceLoader( iCoeEnv ),    

    iResourceOpened( EFalse )

	{

	}

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

//	CBrowserDialogsProvider* CBrowserDialogsProvider::NewL

//

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

EXPORT_C CBrowserDialogsProvider* CBrowserDialogsProvider::NewL(

								MBrowserDialogsProviderObserver* aObserver )

	{

	CBrowserDialogsProvider* self = 

							new (ELeave) CBrowserDialogsProvider( aObserver );

	CleanupStack::PushL( self );

	self->ConstructL( );

	CleanupStack::Pop( self );   // self

	return self;

	}

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

//  CBrowserDialogsProvider::ConstructL()

//

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

void CBrowserDialogsProvider::ConstructL()

	{

	// Load resource file

	AssureResourceL();

	// Tooltip

	iTooltip = CAknInfoPopupNoteController::NewL();

	}

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

//  CBrowserDialogsProvider::~CBrowserDialogsProvider()

//

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

CBrowserDialogsProvider::~CBrowserDialogsProvider()

	{

	iResourceLoader.Close();

	// Delete any dialogs

	CancelAll();

	// Clean up tooltip

	if ( iTooltip )

	    {

	    iTooltip->HideInfoPopupNote();

	    }

	delete iTooltip;

	}

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

//  CBrowserDialogsProvider::DialogNotifyErrorL( TInt aErrCode )

//

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

EXPORT_C void CBrowserDialogsProvider::DialogNotifyErrorL( TInt aErrCode )

	{

    if( aErrCode == KHttpErrIgnore )

       return;

    TInt httpErr = KBrCtlHttpErrorsOffset - aErrCode;

	CTextResolver* textresolver = CTextResolver::NewLC(); 

	TPtrC msg;

    switch ( httpErr )

        {

        case EHttpMultipleChoices: 

        case EHttpMovedPermanently:

        case EHttpMovedTemporarily:

        case EHttpTemporaryRedirect:

            {

            // Id for r_nw_stat_too_many_redirects is -20019, browser errors start at -20000 

            msg.Set( textresolver->ResolveErrorString( KErrTooManyRedirects )); 

            DialogNoteL( msg );

            break;

            }

        default:

            {

            // change error code to browser error code, when trying to open file

            // that doesn't exist

            if ( KErrNotFound == aErrCode )

            	{

            	iCoeEnv.HandleError( KBrowserFileNotFound );

            	}

            else

            	{

				// Handle all others as system error dialog

            	iCoeEnv.HandleError( aErrCode );

            	}

        	break;

            }

        }   // end of switch

   CleanupStack::PopAndDestroy(); //textresolver

	if ( iObserver )

    	{

    	iObserver->ReportDialogEventL( 

    	                            MBrowserDialogsProviderObserver::ENotifyError,

    	                            aErrCode );

        }

	}

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

//  CBrowserDialogsProvider::DialogNotifyHttpErrorL(

//								TInt aErrCode, const TDesC& /*aUri*/ )

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

EXPORT_C void CBrowserDialogsProvider::DialogNotifyHttpErrorL(

								TInt aErrCode, const TDesC& /*aUri*/ )

	{

    TInt httpErr = KBrCtlHttpErrorsOffset - aErrCode;

    CTextResolver* textresolver = CTextResolver::NewLC(); 

	TPtrC msg;	

    switch ( httpErr )

        {

        case EHttpMultipleChoices: 

        case EHttpMovedPermanently:

        case EHttpMovedTemporarily:

        case EHttpTemporaryRedirect:

            {

            // Handle the redirect error dialog browser errors start from -20000 ,id for r_nw_stat_malformed_url is -20019.

			msg.Set( textresolver->ResolveErrorString( KErrTooManyRedirects ));  

			DialogNoteL( msg );

            break;     

            }

        case EHttpBadGateway:

	        {

    	    // Handle the unresolved dns name error dialog

    	    HBufC* msg = NULL;

        	msg = StringLoader::LoadLC( R_BROWSER_NOT_VALID_DNS_NAME);

			DialogNoteL( *msg );			

			CleanupStack::PopAndDestroy();	// msg

			break;

        	}

        default:

            {

            // Handle all others as system error dialog

            msg.Set( textresolver->ResolveErrorString( aErrCode ));     

			DialogNoteL( msg );

            break;

            }

        }   // end of switch			 

    CleanupStack::PopAndDestroy(); //textresolver    

    if ( iObserver )

        {

        iObserver->ReportDialogEventL( 

                                MBrowserDialogsProviderObserver::ENotifyHttpError,

                                KBrCtlHttpErrorsOffset - aErrCode );

        }

	}

//CBrowserDialogsProvider::DialogFileSelectLC( 

//                                              const TDesC& aStartPath,

//												const TDesC& aRootPath,

//												HBufC*& aSelectedFileName )

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

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

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

EXPORT_C TBool CBrowserDialogsProvider::DialogFileSelectLC( 

                                                    const TDesC& aStartPath,

													const TDesC&/*aRootPath*/,

													HBufC*& aSelectedFileName )

	{

	// Launch the AVKON dialog that will use existing path.

	TBool selected( EFalse );

    HBufC* buf = NULL;

    buf = HBufC::NewLC( KMaxFileName );

	TPtr ptr ( buf->Des() );

	// If a recent path exists, use that as the starting point.

	if ( aStartPath.Length() )

		{

		TParsePtrC fileNameParser( aStartPath );

         // Copy drive into the buffer as a way to pass it to AVKON dialog.

        TPtrC ptrDrive( fileNameParser.Drive() );

        // Get phone memory root 

      	TPtrC8 tempPtrC8((const TUint8*)text_phone_memory_root_path);

		// Unicode data will be <= in length to ASCII

		HBufC* rootBuf = HBufC::NewLC(tempPtrC8.Length() + 1);

		rootBuf->Des().Copy(tempPtrC8);

		rootBuf->Des().ZeroTerminate();

		TPtr rootPtr( rootBuf->Des() );

		// Compare phone memory drive with drive from aStartPath

        if( rootPtr.Length() && (rootPtr[0] == ptrDrive[0] ))

			{

			// we are on the phone memory

    		TPtrC ptrPath( fileNameParser.DriveAndPath() );  

       		ptr.Copy(rootPtr); 

        	if ( ptrPath.Length() )

				{// make ptrPath directory relative to a phone root directory

				// remove "C:\\Data\\" from ptrPath

      			if(aStartPath.Match(rootBuf->Des() )) 

					{

					ptrPath.Set( ptrPath.Right( ptrPath.Length() - rootPtr.Length() ) );

					}

				} // for current configuration ptr is "C:\\Data\\", ptrPath is something like

            //  "images//" etc

        	selected = CAknFileSelectionDialog::RunDlgLD(ptr,ptrPath);   	

			}

		else

			{

			TBuf<KMaxPath> rootPath;

			rootPath.Copy( ptrDrive ); 

			ptr.Copy( rootPath );	

			// Remove leading backslash; required for AVKON dialog.

			TPtrC ptrPath( fileNameParser.Path() );

			if ( ptrPath.Length() )

				{

				if ( ptrPath[0] == '\\' ) 

					{

					ptrPath.Set( ptrPath.Right( ptrPath.Length() - 1 ) );

					}

				}	

     		selected = CAknFileSelectionDialog::RunDlgLD( ptr, ptrPath);

			}

     	CleanupStack:: PopAndDestroy(rootBuf);

		if( !selected )

			{

			// if mmc present launch memory selection dialog

			FeatureManager::InitializeLibL();

			TBool mmcSupported( FeatureManager::FeatureSupported( KFeatureIdMmc ) );

			FeatureManager::UnInitializeLib();

			TInt driveInfo( KErrNone );

#ifdef RD_MULTIPLE_DRIVE

            TDriveNumber selectedMemory;

            User::LeaveIfError(

                DriveInfo::GetDefaultDrive( DriveInfo::EDefaultPhoneMemory,

                                            ( TInt& )selectedMemory ) );

#else

			CAknMemorySelectionDialog::TMemory selectedMemory( 

							CAknMemorySelectionDialog::EPhoneMemory );

#endif

			if ( mmcSupported )

				{

#ifdef RD_MULTIPLE_DRIVE

                TDriveNumber defaultRMS;

                User::LeaveIfError(

                    DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRemovableMassStorage,

                                                ( TInt& )defaultRMS ) );

                TUint status;

                RFs& fs = CCoeEnv::Static()->FsSession();

                driveInfo = DriveInfo::GetDriveStatus( fs, ( TInt& )defaultRMS, status );

#else

   				driveInfo = DriveReady( TDriveNumber( EDriveE ) );

#endif

				}

			// Temp variable

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

			TPtr ptrDefaultFolder = defaultFolder->Des();

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

			TPtr ptrDefaultPath = defaultPath->Des();

			if ( ( driveInfo == KErrNone ) && mmcSupported )

				{

				// Run MEMORY SELECTION DIALOG

#ifdef RD_MULTIPLE_DRIVE

				CAknMemorySelectionDialogMultiDrive* memoryDialog = 

					CAknMemorySelectionDialogMultiDrive::NewL( ECFDDialogTypeSelect, 

													 R_MEMORY_SELECTION_DIALOG,

													 EFalse );

#else

				CAknMemorySelectionDialog* memoryDialog = 

					CAknMemorySelectionDialog::NewL( ECFDDialogTypeSelect, 

													 R_MEMORY_SELECTION_DIALOG,

													 EFalse );

#endif

				CleanupStack::PushL( memoryDialog );

				selected = memoryDialog->ExecuteL( selectedMemory,

											   &ptrDefaultPath, 

											   &ptrDefaultFolder );

				CleanupStack::PopAndDestroy(); // memoryDialog

				}

			if ( selected ) 

				{

				selected = CAknFileSelectionDialog::RunDlgLD( ptrDefaultPath, 

														  ptrDefaultFolder );

				if ( selected ) 

					{

					ptr.Copy( ptrDefaultPath );

					}

				}

			CleanupStack::PopAndDestroy(defaultPath); //defaultPath

			CleanupStack::PopAndDestroy(defaultFolder); //defaultFolder

			}

		}

	else

		{

        // aStartPath is NULL

        ptr.Copy( aStartPath );

#ifdef RD_MULTIPLE_DRIVE

		selected = AknCommonDialogsDynMem::RunSelectDlgLD( AknCommonDialogsDynMem::EMemoryTypePhone|

                                                           AknCommonDialogsDynMem::EMemoryTypeInternalMassStorage|

                                                           AknCommonDialogsDynMem::EMemoryTypeMMCExternal|

                                                           AknCommonDialogsDynMem::EMemoryTypeRemote, 

                                                           ptr, R_MEMORY_SELECTION_DIALOG );

#else

		selected = AknCommonDialogs::RunSelectDlgLD( ptr, 

													 R_MEMORY_SELECTION_DIALOG );

#endif

		}

	// return fully qualified file name

	if ( selected )

		{

		aSelectedFileName = buf;

		}

    if ( iObserver )

        {

        iObserver->ReportDialogEventL( 

    	                        MBrowserDialogsProviderObserver::EFileSelect,

    	                        ( TInt ) selected );    

        }       

	return selected;

	}

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

//  CBrowserDialogsProvider::DialogSelectOptionL(

//								const TDesC& aTitle, 

//								TBrCtlSelectOptionType aBrCtlSelectOptionType,

//								CArrayFix<TBrCtlSelectOptionData>& aOptions )

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

EXPORT_C TBool CBrowserDialogsProvider::DialogSelectOptionL(

								const TDesC& aTitle, 

								TBrCtlSelectOptionType aBrCtlSelectOptionType,

								CArrayFix<TBrCtlSelectOptionData>& aOptions )

	{

     iSelectDlg = CBrowserSelectElementDlg::NewL(	aTitle, 

												aBrCtlSelectOptionType, 

												aOptions );

	TInt result = iSelectDlg->ExecuteLD();

    iSelectDlg = 0;

    if ( iObserver )

        {

        iObserver->ReportDialogEventL( 

    	                        MBrowserDialogsProviderObserver::ESelectOption,

    	                        ( TInt ) result );    

        }

    return result;

	}

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

// CBrowserDialogsProvider::DialogUserAuthenticationLC(	

//												const TDesC& /*aUrl**/, 

//												const TDesC& /*aRealm*/, 

//												const TDesC& aDefaultUserName, 

//												HBufC*& aReturnedUserName, 

//												HBufC*& aReturnedPasswd,

//												TBool aBasicAuthentication )

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

EXPORT_C TBool CBrowserDialogsProvider::DialogUserAuthenticationLC(	

												const TDesC& /*aUrl**/, 

												const TDesC& /*aRealm*/, 

												const TDesC& aDefaultUserName, 

												HBufC*& aReturnedUserName, 

												HBufC*& aReturnedPasswd,

												TBool /*aBasicAuthentication*/ )

	{

	TBuf<KBrowserDialogsProviderMaxUsername> username;

    TBuf<KBrowserDialogsProviderMaxPassword> password;

    TBool bTryAgain = ETrue;

	TBool cancelled = ETrue;

    // Fill in default username and notify that previous authentication failed

    if ( aDefaultUserName.Length() )

        {

        username.Copy( aDefaultUserName );

        bTryAgain = ( ConfirmQueryDialogL( R_BROWSER_DLGPROV_AUTH_FAIL_RETRY_QUERY ) != 0 );

        }

    // Show Authentication dialog

    if( bTryAgain )

        {

        switch (GetUserPasswordL( username, password ))

            {

            case EAknSoftkeyOk:

                {

                cancelled = EFalse;

                break;

                }

            case EAknSoftkeyCancel:

            default:

                {

                cancelled = ETrue;

                }

            }

        }

    aReturnedUserName = username.AllocLC();

    aReturnedPasswd = password.AllocLC();

    if ( iObserver )

        {

        iObserver->ReportDialogEventL( 

                            MBrowserDialogsProviderObserver::EUserAuthentication,