MCL/sf/mw/web: comparison browserutilities/downloadmgr/DownloadMgrUiLib/Src/CUserInteractionsUtils.cpp

equal deleted inserted replaced

-:e1bea15f9a39
+:79859ed3eea9
 *
 * Description:  Supports user interaction dialogs for downloads
 *
 */
 // INCLUDE FILES
-#include    <browser_platform_variant.hrh>
+//#include <platform/mw/Browser_platform_variant.hrh>
+#include    <Browser_platform_variant.hrh>
 #include    "CUserInteractionsUtils.h"
 #include    "MDownloadHandlerObserver.h"
-#include    <cdownloadmgruibase.h>
+#include    "CDownloadMgrUiBase.h"
-#include    <cdownloadmgruilibregistry.h>
+#include    "CDownloadMgrUiLibRegistry.h"
-#include    <cdownloadmgruidownloadslist.h>
+#include    "CDownloadMgrUiDownloadsList.h"
-#include    <cdownloadmgruiuserinteractions.h>
+#include    "CDownloadMgrUiUserInteractions.h"
 #include    "UiLibLogger.h"
 #include    "DMgrUiLibPanic.h"
 #include    <DownloadMgrUiLib.rsg>
-#include    <downloadmgrclient.h>
+#include    <DownloadMgrClient.h>
 #include    <AiwGenericParam.h>
 #include    <DocumentHandler.h>
 #include    <coemain.h>
 #include    <ErrorUI.h>
 #include    <eikenv.h>
 #include    <CAknMemorySelectionDialog.h>
 #include    <AknQueryDialog.h>
 #include    <StringLoader.h>
 #include    <AknSoftNotificationParameters.h>
 #include    <AknSoftNotifier.h>
-#include    <AknNoteWrappers.h>
+#include    <aknnotewrappers.h>
-#include    <browserdialogsprovider.h>
+#include    <BrowserDialogsProvider.h>
-#include    <httpdownloadmgrcommon.h>
+#include    <HttpDownloadMgrCommon.h>
-#include    <PathInfo.h>
+#include    <pathinfo.h>
-#include    <aknglobalnote.h>
+#include    <AknGlobalNote.h>
 #include    <Oma2Agent.h>
 #include    <DRMCommon.h>
 #include	<apmrec.h>
 #include	<apgcli.h>
 #include    <s32mem.h>
-#include    <bautils.h>
+#include    "bautils.h"
 #include	<etelmm.h>
-#include	<MmTsy_names.h>
+#include	<mmtsy_names.h>
 #include    <rconnmon.h>
 #include    <DcfEntry.h>
 #include    <DcfRep.h>
+// following line is temporary: AVKON dependency removal
+#undef BRDO_APP_GALLERY_SUPPORTED_FF
 #ifdef BRDO_APP_GALLERY_SUPPORTED_FF
 #include    <MGXFileManagerFactory.h>
 #include    <CMGXFileManager.h>
 #endif
 // -----------------------------------------------------------------------------
 // CUserInteractionsUtils::CUserInteractionsUtils
 // -----------------------------------------------------------------------------
 //
 CUserInteractionsUtils::CUserInteractionsUtils( CDownloadMgrUiBase& aDMgrUiBase,
 MDownloadMgrUiLibRegModel& aRegistryModel )
 :   iCoeEnv( *CCoeEnv::Static() ),
 iDMgrUiBase( aDMgrUiBase ),
 iRegistryModel( aRegistryModel ),
 iDocHandlerUsesTheUi( EFalse )
 {
 }
 // -----------------------------------------------------------------------------
 //
 CUserInteractionsUtils* CUserInteractionsUtils::NewL
 ( CDownloadMgrUiBase& aDMgrUiBase, MDownloadMgrUiLibRegModel& aRegistryModel )
 {
 CUserInteractionsUtils* self =
 new ( ELeave ) CUserInteractionsUtils( aDMgrUiBase, aRegistryModel );
 CleanupStack::PushL( self );
 self->ConstructL();
 CleanupStack::Pop();
 return self;
 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.
 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
 }
 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
 {
 // -----------------------------------------------------------------------------
 // CUserInteractionsUtils::IsRecoverableFailL
 // -----------------------------------------------------------------------------
 //
 TBool CUserInteractionsUtils::IsRecoverableFailL( RHttpDownload& aDownload,
 TInt32 aErrorId ) const
 {
 TBool recoverable( ETrue );
 // What is the error?
 //
 // 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 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
 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();
 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
 }
 else
 {
 User::Leave( retVal );
 }
 // END: Get attributes for generic params
 //Creating generic param list
 CAiwGenericParamList* genericParamList = CAiwGenericParamList::NewLC();
 TAiwVariant iapVariant( iap );
 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
 CleanupStack::PopAndDestroy( refererUri ); // refererUri
 CleanupStack::PopAndDestroy( charset ); // charset
 CLOG_ENTERFN("CUserInteractionsUtils::SaveContentL");
 __ASSERT_DEBUG( iMemSelectionDialog == 0, Panic( EUiLibPanNull ) ); // Only one can run
 TBool boolRet( EFalse );
 if ( !DrmDownloadL( aDownload ) )
 {
 boolRet = SaveContentWithPathSelectionL( aDownload );
 }
 else
 HBufC* dlName = HBufC::NewLC( KMaxPath );
 TPtr dlNamePtr = dlName->Des();
 User::LeaveIfError
 ( aDownload.GetStringAttribute( EDlAttrName, dlNamePtr ) );
 CLOG_WRITE_FORMAT(" EDlAttrName: %S",&dlNamePtr);
 HBufC8* contentType = HBufC8::NewLC( KMaxContentTypeLength );
 TPtr8 contentTypePtr = contentType->Des();
 User::LeaveIfError
 ( aDownload.GetStringAttribute( EDlAttrContentType, contentTypePtr ) );
 CLOG_WRITE(" EDlAttrContentType OK");
 dataType,
 KEntryAttNormal ) );
 CLOG_WRITE_FORMAT(" moveErr: %d",moveErr);
 CLOG_WRITE_FORMAT(" moveRet: %d",moveRet);
 // Delete DocHandler, otherwise IsUiBusy returns ETrue.
 delete iDocHandler;
 iDocHandler = 0;
 iDocHandlerUsesTheUi = EFalse;
 CleanupStack::PopAndDestroy( contentType ); // contentType
 contentType = 0;
 CleanupStack::PopAndDestroy( dlName ); // dlName
 dlName = 0;
 CleanupStack::PopAndDestroy( fileName ); // fileName
 fileName = 0;
 if( moveRet == KUserCancel )
 {
 // The user cancelled the operation.
 }
 else if( moveErr == KErrNone )
 TBool boolRet( EFalse );
 // Select memory
 iMemSelectionDialog = CAknMemorySelectionDialog::NewL
 ( ECFDDialogTypeSave, R_DMUL_MEMORY_SELECTION_DLG,
 /*aShowUnavailableDrives*/EFalse );
 CLOG_WRITE(" CAknMemorySelectionDialog::NewL OK");
 CAknMemorySelectionDialog::TMemory mem( CAknMemorySelectionDialog::EPhoneMemory );
 boolRet = iMemSelectionDialog->ExecuteL( mem );
 CLOG_WRITE_FORMAT(" MEM boolRet: %d",boolRet);
 delete iMemSelectionDialog;
 iMemSelectionDialog = 0;
 if ( boolRet )
 {
 CLOG_WRITE_FORMAT(" mem: %d",(TInt)mem);
 TBool useMmc = (mem == CAknMemorySelectionDialog::EMemoryCard);
 __ASSERT_DEBUG( iFileSelectionDialog == 0, Panic( EUiLibPanNull ) ); // Only one can run
 HBufC* fileName = HBufC::NewLC( KMaxPath );
 TPtr fileNamePtr = fileName->Des();
 User::LeaveIfError
 ( aDownload.GetStringAttribute( EDlAttrName, fileNamePtr ) );
 CLOG_WRITE(" EDlAttrName OK");
 // Select folder
 TInt resourceId = useMmc ? R_DMUL_MMC_FILE_SELECTION_DLG :
 R_DMUL_FILE_SELECTION_DLG;
 iFileSelectionDialog = CAknFileSelectionDialog::NewL
 ( ECFDDialogTypeSave, resourceId );
 CLOG_WRITE(" CAknFileSelectionDialog::NewL OK");
 TPath selectedPath( KNullDesC );
 // Execute dialog - it calls CActiveScheduler::Start(), so be careful
 // when using data members after ExecuteLD!
 // TODO introduce deleted, as it uses data after executeld.
 boolRet = iFileSelectionDialog->ExecuteL( selectedPath );
 CLOG_WRITE_FORMAT(" FILE boolRet: %d",boolRet);
 delete iFileSelectionDialog;
 ( aDownload.SetStringAttribute( EDlAttrDestFilename, *fileName ) );
 CLOG_WRITE(" EDlAttrDestFilename OK");
 User::LeaveIfError( aDownload.Move() );
 CLOG_WRITE(" Move OK");
 }
 CleanupStack::PopAndDestroy( fileName ); // fileName
 }
 CLOG_LEAVEFN("CUserInteractionsUtils::SaveContentWithPathSelectionL");
 return boolRet;
 }
 }
 CleanupStack::PopAndDestroy( 2, original ); // nameBuf, original
 return ret;
 }
 // -----------------------------------------------------------------------------
 // CUserInteractionsUtils::IsDuplicateL
 // -----------------------------------------------------------------------------
 //
 TBool CUserInteractionsUtils::IsDuplicateL( const TPtrC& aFileName )
 // -----------------------------------------------------------------------------
 //
 TBool CUserInteractionsUtils::DeleteWithUserConfirmL( RHttpDownload& aDownload )
 {
 CLOG_ENTERFN("CUserInteractionsUtils::DeleteWithUserConfirmL");
 TInt32 numMediaObjects(0);
 aDownload.GetIntAttribute( EDlAttrNumMediaObjects, numMediaObjects );
 HBufC* fileName = HBufC::NewLC( KMaxPath );
 TPtr fileNamePtr = fileName->Des();
 // In case of album, show the album name. Otherwise show file name.
 TInt err(KErrNone);
 if (numMediaObjects > 1)
 {
 err = aDownload.GetStringAttribute( EDlAttrAlbumName, fileNamePtr );
 }
 else
 {
 err = aDownload.GetStringAttribute( EDlAttrName, fileNamePtr );
 }
 if ( err != KErrNone && err != KErrNotFound )
 {
 User::LeaveIfError( err );
 }
 TBool fileNameSet = ( err == KErrNone );
 HBufC* prompt = StringLoader::LoadLC( R_DMUL_DOWNLOAD_DEL_CONF, *fileName );
 CAknQueryDialog* dlg = CAknQueryDialog::NewL();
 delete iDeleteConfirmDlg;
 iDeleteConfirmDlg = dlg;
 // Execute dialog - it calls CActiveScheduler::Start(), so be careful
 // when using data members after ExecuteLD!
 TInt resp = iDeleteConfirmDlg->ExecuteLD
 ( R_DMUL_DOWNLOAD_YESNO_CONF_Q, *prompt );
 iDeleteConfirmDlg = 0;
 CleanupStack::PopAndDestroy( 2, fileName ); // prompt, fileName
 if ( resp ) // We have to check only that the value is non-zero
 {
 aDownload.GetBoolAttribute( EDlAttrCodDownload,iCodDownload );
 if(iCodDownload)
 			{
 			#ifdef BRDO_APP_GALLERY_SUPPORTED_FF
 			CMGXFileManager* mgFileManager = MGXFileManagerFactory::NewFileManagerL(
 	        CEikonEnv::Static()->FsSession() );
 	        #endif
 	        //Assume that all files to be deleted are valid.
 	        TBool fileNotFound = EFalse;
 			for(TInt i = 1; i <= numMediaObjects; i++)
 		    	{
 HBufC* fileName = HBufC::NewLC( KMaxPath );
 TPtr fileNamePtr = fileName->Des();
 User::LeaveIfError( aDownload.GetStringAttribute( EDlAttrDestFilename,i,fileNamePtr ));
 RFs rfs;
 User::LeaveIfError( rfs.Connect() );
 CleanupClosePushL<RFs>( rfs );
 TFindFile file(rfs);
 TPtrC ptr(KNullDesC);
 //Found out that at least one file is not found
 fileNotFound =ETrue;
 }
 rfs.Delete( fileNamePtr );
 #ifdef BRDO_APP_GALLERY_SUPPORTED_FF
 // Notify Media Gallery about new media file
 if( fileNamePtr.Length() > 0 )
 {
 TRAP_IGNORE( mgFileManager->UpdateL( fileNamePtr ) );
 }
 else
 {
 TRAP_IGNORE( mgFileManager->UpdateL() );
 }
 #else
 if( fileNamePtr.Length() > 0 )
 {
 TRAP_IGNORE( UpdateDCFRepositoryL( fileNamePtr ) );
 }
 #endif
 CleanupStack::PopAndDestroy( &rfs );
 CleanupStack::PopAndDestroy( fileName );
 }
 #ifdef BRDO_APP_GALLERY_SUPPORTED_FF
 delete mgFileManager;
 mgFileManager = NULL;
 #endif
 //Inform the user that atleast one file not found.
 	   		    if(fileNotFound)
 	   		        {
 HBufC* infoPrompt = StringLoader::LoadLC( R_DMUL_ERROR_FILE_NOT_FOUND);
 CAknInformationNote* note = new(ELeave)  CAknInformationNote();
 note->ExecuteLD(*infoPrompt);
 CleanupStack::PopAndDestroy(infoPrompt);
 	   		        }
 			}
 User::LeaveIfError( aDownload.Delete() );
 CLOG_LEAVEFN("CUserInteractionsUtils::DeleteWithUserConfirmL");
 return ETrue; // Deleted
 }
 else
 // -----------------------------------------------------------------------------
 //
 TBool CUserInteractionsUtils::CancelWithUserConfirmL( RHttpDownload& aDownload )
 {
 CLOG_ENTERFN("CUserInteractionsUtils::CancelWithUserConfirmL");
 HBufC* fileName = HBufC::NewLC( KMaxPath );
 TPtr fileNamePtr = fileName->Des();
 TInt err = aDownload.GetStringAttribute( EDlAttrName, fileNamePtr );
 if ( err != KErrNone && err != KErrNotFound )
 {
 HBufC* prompt = StringLoader::LoadLC( R_DMUL_DOWNLOAD_CAN_CONF, *fileName );
 CAknQueryDialog* dlg = CAknQueryDialog::NewL();
 delete iCancelConfirmDlg;
 iCancelConfirmDlg = dlg;
 // Execute dialog - it calls CActiveScheduler::Start(), so be careful
 // when using data members after ExecuteLD!
 TInt resp = iCancelConfirmDlg->ExecuteLD
 ( R_DMUL_DOWNLOAD_YESNO_CONF_Q, *prompt );
 iCancelConfirmDlg = 0;
 CleanupStack::PopAndDestroy( 2, fileName ); // prompt, fileName
 // Do nothing.
 CLOG_LEAVEFN("CUserInteractionsUtils::CancelWithUserConfirmL");
 return EFalse;
 }
 }
 // -----------------------------------------------------------------------------
 // CUserInteractionsUtils::CancelAllWithUserConfirmL
 // -----------------------------------------------------------------------------
 //
 TBool CUserInteractionsUtils::CancelAllWithUserConfirmL( RHttpDownload& /* aDownload */)
 HBufC* prompt = StringLoader::LoadLC( R_DMUL_EXIT_CONF_PLUR );
 CAknQueryDialog* dlg = CAknQueryDialog::NewL();
 delete iCancelConfirmDlg;
 iCancelConfirmDlg = dlg;
 // Execute dialog - it calls CActiveScheduler::Start(), so be careful
 // when using data members after ExecuteLD!
 TInt resp = iCancelConfirmDlg->ExecuteLD
 ( R_DMUL_DOWNLOAD_YESNO_CONF_Q, *prompt );
 iCancelConfirmDlg = 0;
 CleanupStack::PopAndDestroy(); // prompt
 if ( resp ) // We have to check only that the value is non-zero
 {
 TInt count = iRegistryModel.DownloadMgr().CurrentDownloads().Count();
 TInt32 dlState;
 TInt i = 0;
 		       }
 else if(dlState  == EHttpDlFailed )
 		       {
 		       dlState  = EHttpDlMultipleMOFailed;
 		       }
 if(dlState == EHttpDlInprogress || dlState == EHttpDlPaused )
 	    {
 	    i--;
 	    count--;
 	    User::LeaveIfError( (iRegistryModel.DownloadMgr().CurrentDownloads().At(i))->Delete());
 CLOG_ENTERFN("CUserInteractionsUtils::ShowMediaRemovedNoteL");
 if ( iMediaRemovedNote == 0 )
 {
 HBufC* value = iCoeEnv.AllocReadResourceLC
 ( R_DMUL_ERROR_EXT_MEM_REMOVED );
 iMediaRemovedNote =
 new (ELeave) CAknInformationNote( &iMediaRemovedNote );
 iMediaRemovedNote->ExecuteLD( *value );
 CleanupStack::PopAndDestroy( value ); // value
 }
 CLOG_LEAVEFN("CUserInteractionsUtils::ShowMediaRemovedNoteL");
 //
 TBool CUserInteractionsUtils::GetAndSetHttpAuthCredentialsL
 ( RHttpDownload& aDownload )
 {
 CLOG_ENTERFN("CUserInteractionsUtils::GetAndSetHttpAuthCredentialsL");
 HBufC* username = 0;
 HBufC* password = 0;
 // Get the authentication scheme
 TInt32 authScheme(0);
 User::LeaveIfError( getErr );
 }
 // Execute a wait dialog
 TBool resp = iDialogsProv->DialogUserAuthenticationLC
 ( *url, *realm, *userName, username, password,
 authScheme == EAuthBasic );
 if ( resp )
 {
 if ( authScheme == EAuthBasic && BrowserSettingSecWarningL() )
 CleanupStack::PopAndDestroy( 2 ); // username, password
 CleanupStack::PopAndDestroy( realm ); // realm
 CleanupStack::PopAndDestroy( url ); // url
 CleanupStack::PopAndDestroy( userName ); // userName
 CLOG_LEAVEFN("CUserInteractionsUtils::GetAndSetHttpAuthCredentialsL");
 return ( resp );
 }
 // -----------------------------------------------------------------------------
 //
 TBool CUserInteractionsUtils::GetAndSetProxyAuthCredentialsL
 ( RHttpDownload& aDownload )
 {
 CLOG_ENTERFN("CUserInteractionsUtils::GetAndSetProxyAuthCredentialsL");
 HBufC* username = 0;
 HBufC* password = 0;
 // Get the authentication scheme
 TInt32 authScheme(0);
 User::LeaveIfError( aDownload.GetStringAttribute
 ( EDlAttrProxyRealm, realmPtr ) );
 // Execute a wait dialog
 TBool resp = iDialogsProv->DialogUserAuthenticationLC
 ( *url, *realm, *userName, username, password,
 authScheme == EAuthBasic );
 if ( resp )
 {
 if ( authScheme == EAuthBasic && BrowserSettingSecWarningL() )
 CleanupStack::PopAndDestroy( 2 ); // username, password
 CleanupStack::PopAndDestroy( realm ); // realm
 CleanupStack::PopAndDestroy( url ); // url
 CleanupStack::PopAndDestroy( userName ); // userName
 CLOG_LEAVEFN("CUserInteractionsUtils::GetAndSetProxyAuthCredentialsL");
 return ( resp );
 }
 // -----------------------------------------------------------------------------
 resp = iDialogsProv->DialogConfirmL
 ( KNullDesC, *message, *okMsg, *cancelMsg );
 // Clean up the basic authentication dialog memory
 CleanupStack::PopAndDestroy( 3, message );
 // message, okMsg, cancelMsg
 return resp;
 }
 }
 }
 // -----------------------------------------------------------------------------
 // CUserInteractionsUtils::BrowserSettingSecWarningL
 // This method must behave the same as
 // CBrowserSettings::GetHttpSecurityWarnings().
 // See CBrowserSettings !
 // -----------------------------------------------------------------------------
 //
 TBool CUserInteractionsUtils::BrowserSettingSecWarningL()
 // -----------------------------------------------------------------------------
 // CUserInteractionsUtils::InitializeSoftNotifStndL
 // -----------------------------------------------------------------------------
 //
 void CUserInteractionsUtils::InitializeSoftNotifStndL( TVwsViewId aViewId,
 TUid aCustomMessageId,
 const TDesC8& aViewActivationMsg ) const
 {
 CLOG_ENTERFN("CUserInteractionsUtils::InitializeSoftNotifStndL");
 CAknSoftNotificationParameters* params =
 CAknSoftNotificationParameters::NewL
 (
 iDMgrUiBase.ResourceFileName(), R_DMUL_GSN_STND, KMinimumSoftNotePriority,
 R_AVKON_SOFTKEYS_YES_NO__YES,
 CAknNoteDialog::EConfirmationTone, aViewId, aCustomMessageId,
 EAknSoftkeyYes, aViewActivationMsg
 );
 CLOG_WRITE(" params OK");
 CleanupStack::PushL( params );
 iSoftNotifier->AddCustomNotificationL( *params );
 // -----------------------------------------------------------------------------
 // CUserInteractionsUtils::InitializeSoftNotifEmbL
 // -----------------------------------------------------------------------------
 //
 void CUserInteractionsUtils::InitializeSoftNotifEmbL( TVwsViewId aViewId,
 TUid aCustomMessageId,
 const TDesC8& aViewActivationMsg ) const
 {
 CLOG_ENTERFN("CUserInteractionsUtils::InitializeSoftNotifEmbL");
 CAknSoftNotificationParameters* params =
 CAknSoftNotificationParameters::NewL
 (
 iDMgrUiBase.ResourceFileName(), R_DMUL_GSN_EMB, KMinimumSoftNotePriority,
 R_AVKON_SOFTKEYS_YES_NO__YES,
 CAknNoteDialog::EConfirmationTone, aViewId, aCustomMessageId,
 EAknSoftkeyYes, aViewActivationMsg
 );
 CLOG_WRITE(" params OK");
 CleanupStack::PushL( params );
 iSoftNotifier->AddCustomNotificationL( *params );
 // -----------------------------------------------------------------------------
 // CUserInteractionsUtils::CancelSoftNotifStndL
 // -----------------------------------------------------------------------------
 //
 void CUserInteractionsUtils::CancelSoftNotifStndL( TVwsViewId aViewId,
 TUid aCustomMessageId,
 const TDesC8& aViewActivationMsg ) const
 {
 CLOG_ENTERFN("CUserInteractionsUtils::CancelSoftNotifStndL");
 CAknSoftNotificationParameters* params =
 CAknSoftNotificationParameters::NewL
 (
 iDMgrUiBase.ResourceFileName(), R_DMUL_GSN_STND, KMinimumSoftNotePriority,
 R_AVKON_SOFTKEYS_YES_NO__YES,
 CAknNoteDialog::EConfirmationTone, aViewId, aCustomMessageId,
 EAknSoftkeyYes, aViewActivationMsg
 );
 CLOG_WRITE(" params OK");
 CleanupStack::PushL( params );
 //TODO From avkon sources it seems that it identifies the soft notification
 // with the AVKON_NOTE resource ID, which is the same in case of
 // all UI Lib clients!!
 iSoftNotifier->CancelCustomSoftNotificationL( *params );
 CleanupStack::PopAndDestroy( params ); // params
 // -----------------------------------------------------------------------------
 // CUserInteractionsUtils::CancelSoftNotifEmbL
 // -----------------------------------------------------------------------------
 //
 void CUserInteractionsUtils::CancelSoftNotifEmbL( TVwsViewId aViewId,
 TUid aCustomMessageId,
 const TDesC8& aViewActivationMsg ) const
 {
 CLOG_ENTERFN("CUserInteractionsUtils::CancelSoftNotifEmbL");
 CAknSoftNotificationParameters* params =
 CAknSoftNotificationParameters::NewL
 (
 iDMgrUiBase.ResourceFileName(), R_DMUL_GSN_EMB, KMinimumSoftNotePriority,
 R_AVKON_SOFTKEYS_YES_NO__YES,
 CAknNoteDialog::EConfirmationTone, aViewId, aCustomMessageId,
 EAknSoftkeyYes, aViewActivationMsg
 );
 CLOG_WRITE(" params OK");
 CleanupStack::PushL( params );
 iSoftNotifier->CancelCustomSoftNotificationL( *params );
 CancelDeleteConfirmationDialog();
 CancelCancelConfirmationDialog();
 CancelMediaRemovedNote();
 CancelCredentialsQueries();
 CancelSecurityWarning();
 // The soft notifications should not be cancelled here,
 // because they are used in a different context.
 }
 // -----------------------------------------------------------------------------
 // CUserInteractionsUtils::InfoNoteL
 // -----------------------------------------------------------------------------
 //
 void CUserInteractionsUtils::InfoNoteL( TInt aDialogResourceId, const TDesC& aPrompt )
 {
 CLOG_ENTERFN("CUserInteractionsUtils::InfoNoteL");
 CAknNoteDialog* dialog = new (ELeave) CAknNoteDialog
 								( REINTERPRET_CAST( CEikDialog**, &dialog ) );
 	CLOG_WRITE(" new");
 dialog->PrepareLC( aDialogResourceId ) ;
 CLOG_WRITE(" PrepareLC");
 dialog->SetCurrentLabelL( EGeneralNote, aPrompt );
 CLOG_WRITE(" SetCurrentLabelL");
 dialog->RunDlgLD( CAknNoteDialog::ELongTimeout, CAknNoteDialog::ENoTone );
 CLOG_LEAVEFN("CUserInteractionsUtils::InfoNoteL");
 }
 // -----------------------------------------------------------------------------
 // CUserInteractionsUtils::IsUiBusy
 DRMCommon::TContentProtection prot;
 HBufC8* mimeType = 0;
 HBufC8* contentURI = 0;
 TUint dataLength = 0;
 TInt err = drmCommon->GetFileInfo( *fileName,
 prot, mimeType, contentURI, dataLength );
 if ( err == DRMCommon::EVersionNotSupported ||
 ( err == DRMCommon::EOk && ( !mimeType || !contentURI ) ) )
 {
 isCorruptedDcf = ETrue;
 }
 delete mimeType;
 delete contentURI;
 CleanupStack::PopAndDestroy( fileName );
 CleanupStack::PopAndDestroy( drmCommon );
 DRMCommon::TContentProtection prot;
 HBufC8* mimeType = 0;
 HBufC8* contentURI = 0;
 TUint dataLength = 0;
 TInt err = drmCommon->GetFileInfo( *fileName,
 prot, mimeType, contentURI, dataLength );
 if ( err == DRMCommon::EOk )
 {
 if ( !mimeType || !contentURI )
 {
 isBadMimeInDcfL = ETrue;
 // The MIME type in the DCF is also DCF, which is wrong.
 // It should contain the real mime type.
 isBadMimeInDcfL = ETrue;
 }
 }
 delete mimeType;
 delete contentURI;
 CleanupStack::PopAndDestroy( fileName );
 CleanupStack::PopAndDestroy( drmCommon );
 iHandledDownload = 0;
 }
 CLOG_LEAVEFN("CUserInteractionsUtils::DownloadHasBeenDeleted");
 }
 // -----------------------------------------------------------------------------
 // CUserInteractionsUtils::LaunchPdAppL
 // -----------------------------------------------------------------------------
 //
 void CUserInteractionsUtils::LaunchPdAppL( RHttpDownload& aDownload, const TBool aProgressively )
 {
 CLOG_ENTERFN("CUserInteractionsEventHandler::LaunchPdAppL");
 // Get the PD player application's UID for the download
 TUid pdPlayerUid = { 0 };
 HBufC8* contentType = ContentTypeL( aDownload, ETrue, KFirstMoIndex );
 TDataType dataType( *contentType );
 delete contentType;
 contentType = NULL;
 CDocumentHandler* docHandler = CDocumentHandler::NewLC();
 TBool pdSupported = docHandler->CanHandleProgressivelyL( dataType, pdPlayerUid );
 CleanupStack::PopAndDestroy( docHandler ); // docHandler
 if ( pdSupported )
 {
+TInt downloadCnt = iRegistryModel.DownloadCount();
+TBool isProg(EFalse);
+const CDownloadArray& downloads = iRegistryModel.DownloadMgr().CurrentDownloads();
+for ( TInt i = 0; i < downloadCnt ;i++ )
+			{
+	RHttpDownload* dl = downloads.At(i); //current download
+	dl->GetBoolAttribute( EDlAttrProgressive, isProg );
+	if (isProg )
+				{
+dl->SetBoolAttribute( EDlAttrProgressive, EFalse );
+}
+			}
 TInt32 numMediaObjects = 0;
 User::LeaveIfError( aDownload.GetIntAttribute( EDlAttrNumMediaObjects, numMediaObjects ) );
 // Pack download ID into EGenericParamDownloadId.
 TInt32 downloadID( -1 );
 TInt32 activeDownloadID(-1);
 if ( aProgressively )
 {
 User::LeaveIfError( aDownload.GetIntAttribute( EDlAttrId, downloadID ) );
 User::LeaveIfError( aDownload.GetIntAttribute( EDlAttrActiveDownload, activeDownloadID ) );
 }
 CAiwGenericParamList* genParList = CAiwGenericParamList::NewLC();
 TAiwVariant downloadIdVariant( downloadID );
 TAiwGenericParam genericParam( EGenericParamDownloadId, downloadIdVariant );
 genParList->AppendL( genericParam );
 		    // Get first track's name in case of album
 		if (numMediaObjects > KFirstMoIndex)
 		    User::LeaveIfError( aDownload.GetStringAttribute( EDlAttrDestFilename, KFirstMoIndex, fileNamePtr ) );
 		else
 		    User::LeaveIfError( aDownload.GetStringAttribute( EDlAttrDestFilename, 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 );
 CleanupStack::PopAndDestroy( genParList );
 return;
 }
 		TAiwVariant fileNameVariant( fileNamePtr );
 		TAiwGenericParam fileNameParam( EGenericParamFile, fileNameVariant );
 		genParList->AppendL( fileNameParam );
 	// Since we don't have the EGenericParamId for track index we are using EGenericParamUnspecified.
 	// Once we get the generic parameter for the id in future,this will be changed.
 TAiwVariant activeIndexVariant( activeDownloadID );
 TAiwGenericParam activeIndexParam( EGenericParamUnspecified, activeIndexVariant );
 genParList->AppendL( activeIndexParam );
 HBufC8* param8 = HBufC8::NewLC( KMinLength ); // Must be large enough!!
 TPtr8 paramPtr8 = param8->Des();
 RDesWriteStream writeStream( paramPtr8 );
 genParList->ExternalizeL( writeStream );
 		//Instead of Selecting topmost task matching the UID from all the tasks, opening the standalone application
 CAknTaskList *taskList = CAknTaskList::NewL(CEikonEnv::Static()->WsSession());
 TApaTask task = taskList->FindRootApp(pdPlayerUid);
 TInt result = aDownload.SetBoolAttribute( EDlAttrProgressive, ETrue );
 if ( task.Exists() )
 {
 task.BringToForeground();
 // 8-bit buffer is required.
 task.SendMessage( TUid::Uid( 0 ), *param8 ); // Uid is not used
 }
 else
 {
 HBufC* param = HBufC::NewLC( param8->Length() );
 param->Des().Copy( *param8 );
 RApaLsSession appArcSession;
 User::LeaveIfError( appArcSession.Connect() );
 CleanupClosePushL( appArcSession );
 TThreadId id;
 User::LeaveIfError
 (
 appArcSession.StartDocument( *param, pdPlayerUid, id )
 );
 CleanupStack::PopAndDestroy( &appArcSession );
 CleanupStack::PopAndDestroy( param );
 }
 //Store the information whether progressive play is launched or not
 iRegistryModel.UserInteractions().SetProgressiveDownloadLaunched( ETrue );
 if( aProgressively )
 {
 User::LeaveIfError( aDownload.SetIntAttribute( EDlAttrActivePlayedDownload, activeDownloadID ) );
 }
 CleanupStack::PopAndDestroy( param8 );
 		CleanupStack::PopAndDestroy( fileName );
 CleanupStack::PopAndDestroy( genParList );
 }
 CLOG_LEAVEFN("CUserInteractionsEventHandler::LaunchPdAppL");
 }
 #ifdef __DMGR_PD_TESTHARNESS
 // -----------------------------------------------------------------------------
 TPtr fileNamePtr = fileName->Des();
 User::LeaveIfError( aDownload.GetStringAttribute( EDlAttrDestFilename, fileNamePtr ) );
 TAiwVariant fileNameVariant( fileNamePtr );
 TAiwGenericParam fileNameParam( EGenericParamFile, fileNameVariant );
 genParList->AppendL( fileNameParam );
 HBufC8* param8 = HBufC8::NewLC( KMinLength );
 TPtr8 paramPtr8 = param8->Des();
 RDesWriteStream writeStream( paramPtr8 );
 TApaTask task = taskList.FindApp( KTestPdPlayerUid );
 TInt result = aDownload.SetBoolAttribute( EDlAttrProgressive, ETrue );
 if ( task.Exists() )
 {
 // 8-bit buffer is required.
 task.SendMessage( TUid::Uid( 0 ), *param8 ); // Uid is not used
 task.BringToForeground();
 }
 else
 {
 HBufC* param = HBufC::NewLC( param8->Length() );
 param->Des().Copy( *param8 );
 RApaLsSession appArcSession;
 User::LeaveIfError( appArcSession.Connect() );
 CleanupClosePushL( appArcSession );
 TThreadId id;
 User::LeaveIfError(appArcSession.StartDocument( *param, KTestPdPlayerUid, id ));
 CleanupStack::PopAndDestroy( &appArcSession );
 CleanupStack::PopAndDestroy( param );
 }
 CleanupStack::PopAndDestroy( param8 );
 CleanupStack::PopAndDestroy( fileName );
 CleanupStack::PopAndDestroy( genParList );
 CLOG_LEAVEFN("CUserInteractionsEventHandler::TestLaunchPdAppL");
 }
 #endif // __DMGR_PD_TESTHARNESS
 // -----------------------------------------------------------------------------
 // CUserInteractionsUtils::HandleServerAppExit
 void CUserInteractionsUtils::HandleServerAppExit( TInt aReason )
 {
 CLOG_ENTERFN("CUserInteractionsUtils::HandleServerAppExit");
 CLOG_WRITE_FORMAT(" aReason: %d", aReason);
 // DocHandler has finished its task.
 iDocHandlerUsesTheUi = EFalse;
 // Schedule the next download:
 #ifdef _DEBUG
 TRAPD( scheduleErr, iRegistryModel.UserInteractions().SchedulePostponedDownloadL() );
 CLOG_WRITE_FORMAT(" scheduleErr: %d", scheduleErr);
 #else
 TRAP_IGNORE( iRegistryModel.UserInteractions().SchedulePostponedDownloadL() );
 #endif // _DEBUG
 if ( iHandlerObserver )
 {
 iHandlerObserver->NotifyHandlerExit( iHandledDownload, aReason );
 }
 CLOG_LEAVEFN("CUserInteractionsUtils::HandleServerAppExit");
 }
 // -----------------------------------------------------------------------------
 // CUserInteractionsUtils::IsNetworkPdCompatibleL()
 #if !defined( __WINS__ )
 	// this initialization needed for identifying 3G networks
 RTelServer  telServer;
 RMobilePhone    mobilePhone;
 RMobilePhone::TMobilePhoneNetworkMode networkMode;
 User::LeaveIfError( telServer.Connect() );
 User::LeaveIfError( telServer.LoadPhoneModule( KMmTsyModuleName ) );
 TInt numPhones;
 User::LeaveIfError( telServer.EnumeratePhones( numPhones ) );
 TInt32 browserTerminate( 1 );
 CAiwGenericParamList* genParList = CAiwGenericParamList::NewLC();
 TAiwVariant terminateVariant( browserTerminate );
 TAiwGenericParam genericParamTerm( EGenericParamTerminate, terminateVariant );
 genParList->AppendL( genericParamTerm );
 HBufC8* param8 = HBufC8::NewLC( KMinLength ); // Must be large enough!!
 TPtr8 paramPtr8 = param8->Des();
 RDesWriteStream writeStream( paramPtr8 );
 genParList->ExternalizeL( writeStream );
 writeStream.CommitL();
 writeStream.Close();
 		TApaTaskList taskList( CEikonEnv::Static()->WsSession() );
 	    TBool isProgressive (EFalse);
 	    TInt downloadCnt = iRegistryModel.DownloadCount();
 	    const CDownloadArray& downloads = iRegistryModel.DownloadMgr().CurrentDownloads();
 	    TInt j ;
 	    for( j = 0; j < downloadCnt; ++j )
 	        {
 	        RHttpDownload* dl = downloads.At(j); // current download
 	        dl->GetBoolAttribute( EDlAttrProgressive, isProgressive );
 	        if(isProgressive)
 	            {
 	            break;
 	            }
 	        }
 	    for( TInt i = 0; i < KDocPDAppUidCount; i++ )
 	    {
 			TUid KTestPdPlayerUid = {KDocPDAppUidList[ i ]};
 			TApaTask task = taskList.FindApp(KTestPdPlayerUid );		// task for MP app
 			if ( task.Exists() && ( isProgressive || aProgressiveDownloadLaunched ) )
 				{
 				if ( isProgressive )
 				    {
 				    RHttpDownload* dl = downloads.At(j); // current download
 //This Atribute will tell if MP called Delete
 				    //on exit of Browser
 	                dl->SetBoolAttribute( EDlAttrProgressive, EFalse );
 				    }
 				// 8-bit buffer is required.
 				task.SendMessage( TUid::Uid( 0 ), *param8 ); // Uid is not used
 				task.BringToForeground();
 				}
 		}
 CleanupStack::PopAndDestroy( param8 );
 CleanupStack::PopAndDestroy( genParList );
 CLOG_LEAVEFN("CUserInteractionsEventHandler::SendMsgTerminateToPdAppsL");
 }
 // -----------------------------------------------------------------------------
 // Connection monitor
 RConnectionMonitor connMon;
 CleanupClosePushL( connMon );
 User::LeaveIfError( connMon.ConnectL() );
 TConnMonIapInfoBuf infoBuf;
 infoBuf().iCount = 0;
 // Get WLAN IAPs to infoBuf
 connMon.GetPckgAttribute( EBearerIdWLAN ,0 , KIapAvailability, infoBuf, status );
 User::WaitForRequest( status );
 CleanupStack::PopAndDestroy( &connMon );
 if ( !status.Int() && infoBuf().iCount )
 {
 return ETrue;
 }
 return EFalse;
 }
 // ------------------------------------------------------------
 // CUserInteractionsUtils::CanLaunchAsProgDownload()
 // Check if several conditions are met for Progressive Playback
 // ------------------------------------------------------------
 //
 TBool CUserInteractionsUtils::CanLaunchAsProgDownload(
 RHttpDownload& aDownload,
 CDownloadMgrUiDownloadsList& dlList,
 TBool isOma2Dl )
 {
 return progDlOk;
 }
 // ---------------------------------------------------------
 // CUserInteractionsUtils::UpdateDCFRepositoryL()
 // Update saved file to DCFRepository
 // ---------------------------------------------------------
 //
 void CUserInteractionsUtils::UpdateDCFRepositoryL(
 const TDesC& aFileName )
 {
 CLOG_ENTERFN( "CUserInteractionsUtils::UpdateDCFRepositoryL" );
 CLOG_WRITE_FORMAT( " :aFileName=%S", &aFileName );
 CDcfEntry* dcfEntry = NULL;
 dcfEntry = CDcfEntry::NewL();
 CleanupStack::PushL( dcfEntry );
 CDcfRep* dcfRep = NULL;
 dcfRep = CDcfRep::NewL();
 CleanupStack::PushL( dcfRep );
 dcfEntry->SetLocationL( aFileName, 0 );
 CLOG_WRITE(" : SetLocationL OK");
 dcfRep->UpdateL( dcfEntry );
 CLOG_WRITE(" :UpdateL OK");
 CleanupStack::PopAndDestroy(2); // dcfEntry, dcfRep
 CLOG_LEAVEFN("CUserInteractionsUtils::UpdateDCFRepositoryL");
 }
 // ---------------------------------------------------------
 // CUserInteractionsUtils::IsCodDownload()
 // return true if its a COD DL
 // ---------------------------------------------------------
 //
 TBool CUserInteractionsUtils::IsCodDownload()
 {
 return iCodDownload;
 }
 // End of file.

branch	RCL_3
changeset 48	79859ed3eea9
parent 44	800203832575
child 49	919f36ff910f