FCL/sf/mw/web: comparison browserutilities/downloadmgr/DownloadMgrUiLib/Src/CDownloadMgrUiDownloadsList.cpp

equal deleted inserted replaced

-:79859ed3eea9
+:919f36ff910f
 *
 * Description:  Supports Download Menu and Downloads List
 *
 */
 // INCLUDE FILES
-//#include <platform/mw/Browser_platform_variant.hrh>
+#include    <browser_platform_variant.hrh>
-#include    <Browser_platform_variant.hrh>
+#include    <cdownloadmgruidownloadslist.h>
-#include    "CDownloadMgrUiDownloadsList.h"
+#include    <cdownloadmgruilibregistry.h>
-#include    "CDownloadMgrUiLibRegistry.h"
+#include    <cdownloadmgruidownloadmenu.h>
-#include    "CDownloadMgrUiDownloadMenu.h"
 #include    "CDownloadsListArray.h"
 #include    "CDownloadsListDlg.h"
 #include    "AsyncEventHandlerArray.h"
 #include    "DMgrUiLibPanic.h"
 #include    "DownloadMgrUiLib.hrh"
 #include    <coemain.h>
 #include    <eikmenup.h>
 #include    <gulicon.h>
 #include    <uikon.hrh>
 #include    <AknServerApp.h>
-#include    <uriutils.h>
+#include    <UriUtils.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>
 #include    <MediaGalleryUID.h>  //Gallery UIDs
 #endif
 #include    <DocumentHandler.h>
 #include    "bautils.h"
-#include    <BrowserUiSDKCRKeys.h>
+#include    <browseruisdkcrkeys.h>
 #include    <aknnotewrappers.h>
 #include    <StringLoader.h>
 #include    <apgtask.h>
 // FORWARD DECLARATIONS
 class CDownloadsListExecuter;
 // LOCAL FUNCTION PROTOTYPES
 /**
 * Find the given download in the model and give back the ui data and the index.
 * It returns 0, if the given download is not found in aListModel and aIndex is set to KErrNotFound!
 */
 inline TDownloadUiData* FindDlUiData( CDownloadsListArray& aListModel,
 RHttpDownload& aDownload,
 TInt& aIndex );
 #ifdef __WINS__
 TInt AskIapIdL( TUint32& aId );
 */
 NONSHARABLE_CLASS( CDownloadsListExtension ) : public CBase,
 public MDownloadHandlerObserver
 {
 public:  // Constructors and destructor
 /**
 * Two-phased constructor.
 */
 static CDownloadsListExtension* NewL
 ( CDownloadMgrUiDownloadsList& aDownloadsList );
 /**
 * Destructor.
 */
 virtual ~CDownloadsListExtension();
 /**
 * Start a progress info timer update.
 */
 		void StartProgressTimer();
 protected: // Constructors
 /**
 * C++ default constructor.
 */
 		CPeriodic*		iUpdateProgressInfoTimer;
 		/*
 		* callback function for the UpdateProgressInfo
 		*/
 		static TInt		UpdateProgressInfoCallback(TAny* aPtr);
 };
 NONSHARABLE_CLASS( CDownloadsListExecuter ) : public CActive
 {
 public:  // Constructors and destructor
 /**
 * Two-phased constructor.
 */
 static CDownloadsListExecuter* NewL( CDownloadMgrUiDownloadsList& aDownloadsList,
 CDownloadsListExecuter** aReferer );
 /**
 * Two-phased constructor.
 */
 static CDownloadsListExecuter* NewL( CDownloadMgrUiDownloadsList& aDownloadsList,
 CDownloadsListExecuter** aReferer,
 RHttpDownload& aHighlightDl );
 /**
 * Destructor.
 */
 virtual ~CDownloadsListExecuter();
 public: // New
 /**
 * Invoke RunL.
 */
 void Start();
 /**
 * Check if the dialog already exists.
 */
 TBool DialogExists() const;
 /**
 * Get a reference. Panics if null!
 */
 CDownloadsListDlg& Dialog() const;
 /**
 * Execute the dialog now (wait dialog).
 */
 void ExecuteLD();
 private: // Constructors
 /**
 * C++ default constructor.
 */
 CDownloadsListExecuter( CDownloadMgrUiDownloadsList& aDownloadsList,
 CDownloadsListExecuter** aReferer, RHttpDownload* aHighlightDl );
 /**
 * By default Symbian 2nd phase constructor is private.
 */
 CDownloadsListDlg*          iDialog; ///< Not owned - only reference.
 CDownloadsListExecuter**    iReferer;
 RHttpDownload* iHighlightDl; ///< Not owned.
 TBool iProgressiveDownload;
 };
 // -----------------------------------------------------------------------------
 // CDownloadsListExecuter::CDownloadsListExecuter
 // -----------------------------------------------------------------------------
 //
 CDownloadsListExecuter::CDownloadsListExecuter
 ( CDownloadMgrUiDownloadsList& aDownloadsList,
 CDownloadsListExecuter** aReferer,
 RHttpDownload* aHighlightDl )
 :   CActive( CActive::EPriorityHigh ), // EPriorityHigh to be visible ASAP.
 iDownloadsList( aDownloadsList ),
 iReferer( aReferer ),
 iHighlightDl( aHighlightDl )
 {
 CActiveScheduler::Add( this );
 }
 // -----------------------------------------------------------------------------
 //
 CDownloadsListExecuter* CDownloadsListExecuter::NewL
 ( CDownloadMgrUiDownloadsList& aDownloadsList, CDownloadsListExecuter** aReferer )
 {
 CDownloadsListExecuter* self =
 new (ELeave) CDownloadsListExecuter( aDownloadsList, aReferer, 0 );
 CleanupStack::PushL( self );
 self->ConstructL();
 CleanupStack::Pop();
 return self;
 // -----------------------------------------------------------------------------
 // CDownloadsListExecuter::NewL
 // -----------------------------------------------------------------------------
 //
 CDownloadsListExecuter* CDownloadsListExecuter::NewL
 ( CDownloadMgrUiDownloadsList& aDownloadsList,
 CDownloadsListExecuter** aReferer,
 RHttpDownload& aHighlightDl )
 {
 CDownloadsListExecuter* self =
 new (ELeave) CDownloadsListExecuter
 ( aDownloadsList, aReferer, &aHighlightDl );
 CleanupStack::PushL( self );
 self->ConstructL();
 CleanupStack::Pop();
 // -----------------------------------------------------------------------------
 //
 void CDownloadsListExecuter::ExecuteLD()
 {
 CLOG_ENTERFN("CDownloadsListExecuter::ExecuteLD");
 delete iDialog;
 iDialog = NULL;
 iDialog = CDownloadsListDlg::NewL( iDownloadsList, iProgressiveDownload );
 // No leaving functions before ExecuteLD!
 // If there is download that should be highlighted:
 if ( iHighlightDl )
 {
 iDialog->HighlightDownload( *iHighlightDl );
 }
 // Execute wait dialog... While it is running, 'this' can be deleted:
 TBool deleted( EFalse );
 iDeleted = &deleted;
 TRAP_IGNORE( iDialog->ExecuteLD() );
 iDeleted = 0; // No more needed.
 {
 if( !iDownloadsList.GetDownloadHide() )
 {
 delete iDialog;
 }
 iDownloadsList.SetDownloadListHide( EFalse );
 iDialog = NULL;
 // Reset owner pointer to this object.
 	    if ( iReferer )
 {
 *iReferer = 0;
 CLOG_WRITE(" referer set was to 0");
 }
 // and delete this
 delete this;
 }
 CLOG_LEAVEFN("CDownloadsListExecuter::ExecuteLD");
 }
 // -----------------------------------------------------------------------------
 // CDownloadsListExecuter::DoCancel
 // -----------------------------------------------------------------------------
 //
 TInt CDownloadsListExecuter::RunError(TInt /*aError*/)
 {
 CLOG_ENTERFN("CDownloadsListExecuter::RunError");
 // Reset owner pointer to this object.
 if ( iReferer )
 {
 *iReferer = 0;
 }
 delete this;
 CLOG_LEAVEFN("CDownloadsListExecuter::RunError");
 return 0;
 }
 // ============================ MEMBER FUNCTIONS ===============================
 // -----------------------------------------------------------------------------
 // CDownloadsListExtension::CDownloadsListExtension
 // -----------------------------------------------------------------------------
 //
 CDownloadsListExtension::CDownloadsListExtension
 ( CDownloadMgrUiDownloadsList& aDownloadsList )
 :   iDownloadsList( aDownloadsList ),
 iIapId( 0 ),
 iIapIdGotAndSet( ETrue )
 {
 }
 // -----------------------------------------------------------------------------
 //
 CDownloadsListExtension* CDownloadsListExtension::NewL
 ( CDownloadMgrUiDownloadsList& aDownloadsList )
 {
 CDownloadsListExtension* self =
 new (ELeave) CDownloadsListExtension( aDownloadsList );
 CleanupStack::PushL( self );
 self->ConstructL();
 CleanupStack::Pop();
 return self;
 // Do nothing if visible?
 CLOG_WRITE(" already visible");
 }
 else
 {
 iDownloadsListExecuter =
 CDownloadsListExecuter::NewL( iDownloadsList, &iDownloadsListExecuter );
 iDownloadsListExecuter->ExecuteLD();
 }
 CLOG_LEAVEFN("CDownloadsListExtension::DisplayDownloadsListL");
 // Do nothing if visible?
 CLOG_WRITE(" already visible");
 }
 else
 {
 iDownloadsListExecuter =
 CDownloadsListExecuter::NewL( iDownloadsList, &iDownloadsListExecuter );
 iDownloadsListExecuter->Start();
 }
 CLOG_LEAVEFN("CDownloadsListExtension::DisplayDownloadsListAsynchronouslyL");
 //
 void CDownloadsListExtension::StartProgressTimer()
 {
 	iUpdateProgressInfoTimer->Start(
 		0,
 		KUpdateProgressInfoInterval,
 		TCallBack( UpdateProgressInfoCallback, this ) );
 }
 // -----------------------------------------------------------------------------
 CLOG_WRITE(" iEventHandlerArray");
 	iIsTimerStarted = EFalse;
 	iProgressiveDownload = EFalse;
 	iRegistryModel.DownloadMgr().GetBoolAttribute(EDlMgrProgressiveDownload, iProgressiveDownload);
 CLOG_LEAVEFN("CDownloadMgrUiDownloadsList::ConstructL");
 //whether the platform supports gallery app or not; defined in browser_platfrom_variant.hrh
 #ifdef BRDO_APP_GALLERY_SUPPORTED_FF
 iPlatformSupportsGallery = ETrue;
 #endif
 }
 // -----------------------------------------------------------------------------
 // CDownloadMgrUiDownloadsList::NewL
 // -----------------------------------------------------------------------------
 //
 CDownloadMgrUiDownloadsList* CDownloadMgrUiDownloadsList::NewL
 ( CDownloadMgrUiLibRegistry& aRegistryModel )
 {
 CDownloadMgrUiDownloadsList* self =
 new ( ELeave ) CDownloadMgrUiDownloadsList( aRegistryModel );
 CleanupStack::PushL( self );
 self->ConstructL();
 CleanupStack::Pop();
 return self;
 CLOG_WRITE(" iDownloadMenu");
 // iExtension should be the last deleted.
 delete iExtension;
 iExtension = 0;
 CLOG_WRITE(" iExtension");
 delete iAIWServiceHandler;
 CLOG_LEAVEFN("CDownloadMgrUiDownloadsList::~CDownloadMgrUiDownloadsList");
 }
 // -----------------------------------------------------------------------------
 // CDownloadMgrUiDownloadsList::DownloadMenu
 // -----------------------------------------------------------------------------
 //
 EXPORT_C
 CDownloadMgrUiDownloadMenu& CDownloadMgrUiDownloadsList::DownloadMenu() const
 {
 __ASSERT_DEBUG( iDownloadMenu, Panic( EUiLibPanNull ) );
 return(*iDownloadMenu);
 }
 // -----------------------------------------------------------------------------
 // CDownloadMgrUiDownloadsList::DisplayDownloadsListL
 // -----------------------------------------------------------------------------
 //
 EXPORT_C
 void CDownloadMgrUiDownloadsList::DisplayDownloadsListL()
 {
 CLOG_ENTERFN("CDownloadMgrUiDownloadsList::DisplayDownloadsListL");
 long noMediaDls = 0;
 iRegistryModel.DownloadMgr().GetIntAttribute( EDlMgrNoMediaDls, noMediaDls );
 TInt dlCount = iRegistryModel.DownloadMgr().CurrentDownloads().Count();
 if (dlCount > noMediaDls)
 	iExtension->DisplayDownloadsListAsynchronouslyL();
 CLOG_LEAVEFN("CDownloadMgrUiDownloadsList::DisplayDownloadsListL");
 }
 // -----------------------------------------------------------------------------
 // CDownloadMgrUiDownloadsList::DisplayDownloadsListL
 // -----------------------------------------------------------------------------
 // CDownloadMgrUiDownloadsList::CancelDisplayingDownloadsList
 // -----------------------------------------------------------------------------
 //
 EXPORT_C
 void CDownloadMgrUiDownloadsList::CancelDisplayingDownloadsList()
 {
 CLOG_ENTERFN("CDownloadMgrUiDownloadsList::CancelDisplayingDownloadsList");
 delete iDialog;
 iDialog = 0;
 // -----------------------------------------------------------------------------
 // CDownloadMgrUiDownloadsList::IsVisible
 // -----------------------------------------------------------------------------
 //
 EXPORT_C
 TBool CDownloadMgrUiDownloadsList::IsVisible() const
 {
 return iExtension->IsDialogVisible();
 }
 // -----------------------------------------------------------------------------
 // CDownloadMgrUiDownloadsList::Count
 // -----------------------------------------------------------------------------
 //
 EXPORT_C
 TInt CDownloadMgrUiDownloadsList::Count() const
 {
 return ((iListModel!=NULL)?iListModel->Count():0);
 }
 // Not yet supported functions
 EXPORT_C
 void CDownloadMgrUiDownloadsList::GetIntAttributeL( const TUint /*aAttribute*/, TInt32& /*aValue*/ )
 {
 User::Leave( KErrNotSupported );
 }
 EXPORT_C
 void CDownloadMgrUiDownloadsList::GetBoolAttributeL( const TUint /*aAttribute*/, TBool& /*aValue*/ )
 {
 User::Leave( KErrNotSupported );
 }
 EXPORT_C
 void CDownloadMgrUiDownloadsList::GetStringAttributeL( const TUint /*aAttribute*/, TDes16& /*aValue*/  )
 {
 User::Leave( KErrNotSupported );
 }
 EXPORT_C
 void CDownloadMgrUiDownloadsList::GetStringAttributeL( const TUint /*aAttribute*/, TDes8& /*aValue*/  )
 {
 User::Leave( KErrNotSupported );
 }
 EXPORT_C
 void CDownloadMgrUiDownloadsList::SetIntAttributeL( const TUint /*aAttribute*/, TInt32 /*aValue*/ )
 {
 User::Leave( KErrNotSupported );
 }
 EXPORT_C
 void CDownloadMgrUiDownloadsList::SetBoolAttributeL( const TUint /*aAttribute*/, TBool /*aValue*/ )
 {
 User::Leave( KErrNotSupported );
 }
 EXPORT_C
 void CDownloadMgrUiDownloadsList::SetStringAttributeL( const TUint /*aAttribute*/, const TDesC16& /*aValue*/ )
 {
 User::Leave( KErrNotSupported );
 }
 EXPORT_C
 void CDownloadMgrUiDownloadsList::SetStringAttributeL( const TUint /*aAttribute*/, const TDesC8& /*aValue*/ )
 {
 User::Leave( KErrNotSupported );
 }
 // -----------------------------------------------------------------------------
 // CDownloadMgrUiDownloadsList::AddDownloadsToListModelL
 // -----------------------------------------------------------------------------
 //
 void CDownloadMgrUiDownloadsList::AddDownloadsToListModelL
 ( CDownloadsListArray& aLBModel, RHttpDownloadMgr& aDownloadMgr )
 {
 TInt downloads = aDownloadMgr.CurrentDownloads().Count();
 for ( TInt i = 0; i < downloads; ++i )
 {
 RHttpDownload* download =
 (RHttpDownload*)(aDownloadMgr.CurrentDownloads().At(i));
 // Extract the necessary information from 'download' and
 // add a list box item.
 (void)AddDownloadToListModelL( aLBModel, *download );
 }
 }
 // -----------------------------------------------------------------------------
 // CDownloadMgrUiDownloadsList::AddDownloadToListModelL
 // This is a very expensive method, so when updating list box items,
 // call the less expensive 'update' methods!
 // -----------------------------------------------------------------------------
 //
 TInt CDownloadMgrUiDownloadsList::AddDownloadToListModelL
 ( CDownloadsListArray& aLBModel, RHttpDownload& aDownload )
 // It is already on the list - do not add it again.
 CLOG_WRITE_FORMAT(" aDownload already on list (%d)",itemIndex);
 }
 else
 {
 // Do not add the download to the list if the storage
 // media is not in the device.
 TBool noMedia( EFalse );
 User::LeaveIfError( aDownload.GetBoolAttribute
 ( EDlAttrNoMedia, noMedia ) );
 CLOG_WRITE_FORMAT(" EDlAttrNoMedia: %d",noMedia);
 // Do not add the download to the list if it is hidden
 TBool isHidden( EFalse );
 User::LeaveIfError( aDownload.GetBoolAttribute
 ( EDlAttrHidden, isHidden ) );
 CLOG_WRITE_FORMAT(" EDlAttrHidden: %d",isHidden);
 if ( noMedia || isHidden )
 {
 // Do not add it to the list - hide it from the user.
 }
 else
 // Quite big structure, allocate it on the heap!
 TDownloadUiData* dlData = new (ELeave) TDownloadUiData;
 CleanupStack::PushL( dlData );
 TInt err(KErrNone);
 //      Get progress info
 err = aDownload.GetIntAttribute
 ( EDlAttrState, dlData->iDownloadState );
 CLOG_WRITE_FORMAT(" EDlAttrState err: %d",err);
 User::LeaveIfError( err );
 //Changes for the bug JERI-7P8CF2
 //Changes made in the server side to fix the video center receiving unexpected events
 //Reassigning these events back to the changes done in server side
 if(dlData->iDownloadState  == EHttpDlCompleted )
 		        {
 CLOG_WRITE_FORMAT(" EDlAttrLength err: %d",err);
 if ( err != KErrNone && err != KErrNotFound )
 {
 User::LeaveIfError( err );
 }
 // Number of media objects in download ( inalbum)?
 err = aDownload.GetIntAttribute
 ( EDlAttrNumMediaObjects, dlData->iNumMediaObjects );
 CLOG_WRITE_FORMAT(" EDlAttrNumMediaObjects err: %d",err);
 User::LeaveIfError( err );
 //      Get file name
 // In case of album - if download is complete, query album name,
 // otherwise query track name
 if ((dlData->iNumMediaObjects > 1) &&
 (EHttpDlMultipleMOCompleted == dlData->iDownloadState))
 {
 err = aDownload.GetStringAttribute
 ( EDlAttrAlbumName, dlData->iName );
 CLOG_WRITE_FORMAT(" EDlAttrAlbumName err: %d",err);
 }
 else
 {
 err = aDownload.GetStringAttribute
 ( EDlAttrName, dlData->iName );
 CLOG_WRITE_FORMAT(" EDlAttrName err: %d",err);
 }
 if ( err != KErrNone && err != KErrNotFound )
 {
 User::LeaveIfError( err );
 }
 CLOG_WRITE_FORMAT(" EDlAttrName: %S",&(dlData->iName));
 // If download name is empty, use the file name got from URI
 if ( dlData->iName.Length() == 0 )
 {
 HBufC* url = HBufC::NewLC( KMaxUrlLength );
 TPtr urlPtr = url->Des();
 // Is the download pausable?
 User::LeaveIfError( aDownload.GetBoolAttribute
 ( EDlAttrPausable, dlData->iPausable ) );
 CLOG_WRITE_FORMAT(" EDlAttrPausable: %d",dlData->iPausable);
 // Is the download on an external/removable memory (like MMC)?
-err = aDownload.GetBoolAttribute
+err = aDownload.GetIntAttribute
-( EDlAttrDestRemovable, dlData->iIsOnExternalMemory );
+( EDlAttrDestRemovable, dlData->iExternalMemoryStatus );
 CLOG_WRITE_FORMAT(" EDlAttrDestRemovable err: %d",err);
 // 'err' is ignored.
-CLOG_WRITE_FORMAT(" EDlAttrDestRemovable: %d",dlData->iIsOnExternalMemory);
+CLOG_WRITE_FORMAT(" EDlAttrDestRemovable: %d",dlData->iExternalMemoryStatus);
 // Currently active media object's index (in album)?
 err = aDownload.GetIntAttribute
 ( EDlAttrActiveDownload, dlData->iActiveMoIndex );
 CLOG_WRITE_FORMAT(" EDlAttrActiveDownload err: %d",err);
 User::LeaveIfError( err );
 // First add the handler app's icon to model, so that we then
 // know the index of it that can then be set in the item text,
 // which is then also added to the model.
 dlData->iIconIndex =
 iListModel->AddHandlerAppIconL( dlData->iContentType );
 CLOG_WRITE(" AddHandlerAppIconL OK");
 // Add now the structure to the model:
 itemIndex = aLBModel.AppendL( *dlData, aDownload );
 iListModel->Delete( index );
 }
 else
 {
 iListModel->Delete( index );
 // Update view
 if ( iExtension->IsDialogVisible() )
 {
 iExtension->DlExecuter().Dialog().HandleModelChangeL( EDownloadRemoved, index );
 CLOG_WRITE(" HandleModelChangeL OK");
 }
 }
 }
 }
 CLOG_LEAVEFN("CDownloadMgrUiDownloadsList::DeleteDownloadL");
 }
 // -----------------------------------------------------------------------------
 // CDownloadMgrUiDownloadsList::DeleteDownloadL
 // -----------------------------------------------------------------------------
 //
 TBool CDownloadMgrUiDownloadsList::IsOneProgressive()
 {
 TBool anyOneProgress = EFalse;
 if (iListModel == NULL)
 {
 	  return EFalse;
 }
 else
 {
 TInt count = Count();
 for ( TInt i = 0; i < count; ++i )
 {
 	 RHttpDownload& download = iListModel->Download(i);
 TInt err = download.GetBoolAttribute( EDlAttrProgressive, anyOneProgress );
 // If there is a COD download and check if it is attached. Then set it as attached while resuming
 TBool isCodDownload;
 download.GetBoolAttribute(EDlAttrCodDownload,isCodDownload);
 if(isCodDownload && anyOneProgress )
 download.SetBoolAttribute( EDlAttrProgressive, ETrue );
 }
 THttpProgressState state;
 if( anyOneProgress )
 	{
 	download.GetIntAttribute(EDlAttrProgressState, (TInt32&)state);
 	if(state == EHttpProgContentFileMoved || state == EHttpProgContentFileMovedAndDestFNChanged )
 	    {
 	    anyOneProgress = 0;//once the move() has happened the progressive Download is finished
 	    }                  //and we can  bring MP to foreground and start another PD
 	}
 CLOG_WRITE_FORMAT(" EDlAttrProgressive err: %d",err);
 if ( anyOneProgress )
 return ETrue;
 }
 }
 return anyOneProgress;
 }
 // -----------------------------------------------------------------------------
 // CDownloadMgrUiDownloadsList::NewDownloadCreatedL
 // -----------------------------------------------------------------------------
 //
 void CDownloadMgrUiDownloadsList::NewDownloadCreatedL( RHttpDownload& aDownload )
 __ASSERT_DEBUG( iExtension->IsDialogVisible(), Panic( EUiLibPanProgressNotVisible ) );
 // Update the download progress info at the current index.
 // First find the current download in the model.
 TInt index(0);
 TDownloadUiData* dlDataPtr = FindDlUiData( *iListModel, aDownload, index );
-if ( !dlDataPtr )
+if ( !dlDataPtr || dlDataPtr->iDownloadState == EHttpDlCompleted )
 {
-// do nothing
+/*
+For download completed do not update any thing in UI list.Download was small and may
+have completed before you could recieve progress notification
+do nothing
+*/
 }
 else
 {
 // Create a local copy
 TDownloadUiData dlData = *dlDataPtr;
 // Track changed? We need to change icon of new track
 TInt32 moIndex(0);
 User::LeaveIfError( aDownload.GetIntAttribute( EDlAttrActiveDownload, moIndex ) );
 TBool activeIndexChanged = (dlData.iActiveMoIndex != moIndex);
 // Update download state - this must always be done!
 dlData.iDownloadState = aEvent.iDownloadState;
 		dlData.iProgressState = aEvent.iProgressState;
 		dlData.iActiveMoIndex = moIndex;
 aDownload.GetStringAttribute( EDlAttrName, dlData.iName );
 // Permanent redirection changes the filename.
 if ( aEvent.iProgressState == EHttpProgRedirectedPermanently ||
 aEvent.iProgressState == EHttpProgRedirectedTemporarily )
 {
 CLOG_WRITE(" Redirection");
 }
 else if ( aEvent.iProgressState == EHttpProgResponseHeaderReceived )
-	{
+{
 // Is the download on an external/removable memory (like MMC)?
-aDownload.GetBoolAttribute
+// Return value is ignored.
-( EDlAttrDestRemovable, dlData.iIsOnExternalMemory );
+aDownload.GetIntAttribute( EDlAttrDestRemovable, dlData.iExternalMemoryStatus );
-// Return value is ignored.
+CLOG_WRITE_FORMAT(" EDlAttrDestRemovable: %d",dlData.iExternalMemoryStatus);
-CLOG_WRITE_FORMAT(" EDlAttrDestRemovable: %d",dlData.iIsOnExternalMemory);
+}
-	}
 else if ( aEvent.iProgressState == EHttpProgDlNameChanged )
 {
 CLOG_WRITE(" EHttpProgDlNameChanged");
 }
 if (( aEvent.iProgressState == EHttpProgContentTypeChanged ) || activeIndexChanged )
 {
 // Update handler application icon
 // Also update the content type, because the handler application
 // icon depends from this.
 CLOG_WRITE_FORMAT(" EHttpProgContentTypeChanged: ActiveIndex - %d",dlData.iActiveMoIndex);
 HBufC8* contentType = iUiUtils->ContentTypeL( aDownload, ETrue );
 // Not pushed to cleanup stack - unnecessary.
 // There is a limit for dlData.iContentType
 delete contentType;
 contentType = 0;
 dlData.iIconIndex = iListModel->AddHandlerAppIconL( dlData.iContentType );
 }
 // Update the progress info.
 User::LeaveIfError( aDownload.GetIntAttribute( EDlAttrDownloadedSize,
 dlData.iDownloadedSize ) );
 User::LeaveIfError( aDownload.GetIntAttribute( EDlAttrLength,
 dlData.iFullSize ) );
 // Update the download ui data in the 'model'.
 iListModel->UpdateL( index, dlData );
 // Update the 'view'
 iExtension->DlExecuter().Dialog().HandleModelChangeL( EDownloadChanged, index );
 //
 void CDownloadMgrUiDownloadsList::DownloadPausedL
 ( RHttpDownload& aDownload, THttpDownloadEvent aEvent )
 {
 CLOG_ENTERFN("CDownloadMgrUiDownloadsList::DownloadPausedL");
 __ASSERT_DEBUG( iExtension->IsDialogVisible(), Panic( EUiLibPanPausedNotVisible ) );
 // First find the current download in the model.
 TInt index(0);
 TDownloadUiData* dlDataPtr = FindDlUiData( *iListModel, aDownload, index );
 if ( !dlDataPtr )
 // Update download state - this must always be done!
 dlData.iDownloadState = aEvent.iDownloadState;
 		dlData.iProgressState = aEvent.iProgressState;
 		User::LeaveIfError( aDownload.GetIntAttribute( EDlAttrActiveDownload, dlData.iActiveMoIndex ) );
 		aDownload.GetStringAttribute( EDlAttrName, dlData.iName );
 // Here we have to initialize the full size, if the
 // content-type header arrives!!
 if ( aEvent.iProgressState == EHttpContentTypeReceived )
 {
 TInt err = aDownload.GetIntAttribute( EDlAttrLength, dlData.iFullSize );
 if ( err != KErrNone && err != KErrNotFound )
 {
 User::LeaveIfError( err );
 }
 // Also update the content type, because the handler application
 // icon depends from this.
 HBufC8* contentType = iUiUtils->ContentTypeL( aDownload, ETrue );
 // Not pushed to cleanup stack - unnecessary.
 // There is a limit for dlData.iContentType
 if ( contentType->Length() > KMaxContentTypeLength )
 delete contentType;
 contentType = 0;
 dlData.iIconIndex = iListModel->AddHandlerAppIconL( dlData.iContentType );
 }
 // Update downloaded size (introduced, because for non-pausable downloads
 // paused command sets downloaded size back to 0 kB).
 User::LeaveIfError( aDownload.GetIntAttribute
 ( EDlAttrDownloadedSize, dlData.iDownloadedSize ) );
 // Update the download ui data in the 'model'.
 iListModel->UpdateL( index, dlData );
 // Update the 'view'
 iExtension->DlExecuter().Dialog().HandleModelChangeL( EDownloadChanged, index );
 // Also need to update the middle softkey
 iExtension->DlExecuter().Dialog().HandleMiddleSoftKeyChangeL();
 }
 CLOG_LEAVEFN("CDownloadMgrUiDownloadsList::DownloadPausedL");
 }
 // -----------------------------------------------------------------------------
 // CDownloadMgrUiDownloadsList::DownloadCompletedL
 TDownloadUiData dlData = *dlDataPtr;
 // Update download state - this must always be done!
 dlData.iDownloadState = aEvent.iDownloadState;
 		dlData.iProgressState = aEvent.iProgressState;
 		User::LeaveIfError( aDownload.GetIntAttribute( EDlAttrActiveDownload, dlData.iActiveMoIndex ) );
 		// In case of Album download, change the name to Album name
 		if (dlData.iNumMediaObjects > 1)
 		    {
 		    aDownload.GetStringAttribute( EDlAttrAlbumName, dlData.iName );
 		    }
-		else if (dlData.iProgressState == EHttpProgContentFileMovedAndDestFNChanged)
+		else if ( !(dlData.iProgressState == EHttpProgContentFileMoved) || dlData.iProgressState == EHttpProgContentFileMovedAndDestFNChanged)
 			// Filename changed, get the updated filename
 		    {
 			CLOG_WRITE(" EHttpProgDlNameChanged");
 	        aDownload.GetStringAttribute( EDlAttrName, dlData.iName );
 		    }
 __ASSERT_DEBUG( aEvent.iDownloadState == EHttpDlMultipleMOCompleted,
 Panic( EUiLibPanDlStateNotCompleted ) );
 if( dlData.iProgressState == EHttpProgContentFileMoved  || dlData.iProgressState == EHttpProgContentFileMovedAndDestFNChanged )
 {
+aDownload.GetIntAttribute( EDlAttrDestRemovable, dlData.iExternalMemoryStatus );
 HBufC8* contentType = iUiUtils->ContentTypeL( aDownload, ETrue, KFirstMoIndex );
 if ( contentType->Length() > KMaxContentTypeLength )
 {
 // What can we do? Use an empty mime string.
 CLOG_WRITE_FORMAT(" Length overflow: %d",contentType->Length());
 contentType = 0;
 contentType = KNullDesC8().AllocL();
 }
 dlData.iContentType.Copy( *contentType );
 delete contentType;
 dlData.iIconIndex =
 iListModel->AddHandlerAppIconL( dlData.iContentType );
 }
 // Unnecessary to update dlData.iDownloadedSize, as it is not displayed.
 // Update the download ui data in the 'model'.
 iListModel->UpdateL( index, dlData );
 // Update the 'view'
 iExtension->DlExecuter().Dialog().HandleModelChangeL( EDownloadChanged, index );
 // Also need to update the middle softkey
 iExtension->DlExecuter().Dialog().HandleMiddleSoftKeyChangeL();
 }
 }
 // -----------------------------------------------------------------------------
 dlData.iDownloadState = aEvent.iDownloadState;
 		dlData.iProgressState = aEvent.iProgressState;
 		User::LeaveIfError( aDownload.GetIntAttribute( EDlAttrActiveDownload, dlData.iActiveMoIndex ) );
 // By default, update the progress info. Only the downloaded size changes.
 User::LeaveIfError( aDownload.GetIntAttribute( EDlAttrDownloadedSize,
 dlData.iDownloadedSize ) );
 // Update the download ui data in the 'model'.
 iListModel->UpdateL( index, dlData );
 // Update the 'view'
 iExtension->DlExecuter().Dialog().HandleModelChangeL( EDownloadChanged, index );
 dlData.iPausable = aPausable;
 // Update the download ui data in the 'model'.
 iListModel->UpdateL( index, dlData );
 }
 }
 // -----------------------------------------------------------------------------
 // CDownloadMgrUiDownloadsList::HideMenu
 // -----------------------------------------------------------------------------
 //
 void CDownloadMgrUiDownloadsList::HideMenu()
 {
 				// Update progress info every KUpdateProgressInfoInterval
 				if (!iIsTimerStarted )
 {
 					iIsTimerStarted = ETrue;
 					// start the timer.
 					iExtension->StartProgressTimer();
 }
 				if (iExtension->iIsUpdateInfoAllowed)
 {
 }
 case EHttpDlMoved:
 {
 // Download moved to this session.
 // Add it to the list
 NewDownloadCreatedL( aDownload );
 break;
 }
 case EHttpDlMediaRemoved:
 {
 // Remove the download from the list
 DeleteDownloadL( aDownload );
 break;
 }
 case EHttpDlMediaInserted:
 {
 // Add new download to the list
 NewDownloadCreatedL( aDownload );
 break;
 }
 case EHttpDlPausable:
 case EHttpDlNonPausable:
 {
 // Update the download UI data
 PauseableStateChangedL( aDownload, aEvent.iDownloadState==EHttpDlPausable );
 // -----------------------------------------------------------------------------
 //
 void CDownloadMgrUiDownloadsList::PreLayoutDynInitL( CDownloadsListDlg& aDialog )
 {
 CLOG_ENTERFN("CDownloadMgrUiDownloadsList::PreLayoutDynInitL");
 __ASSERT_DEBUG( iExtension->IsDialogVisible(), Panic( EUiLibPanNull ) );
 delete iListModel;
 iListModel = NULL;
 iListModel = CDownloadsListArray::NewL();
 CLOG_WRITE(" NewL OK");
 if ( aiwServiceId != KAiwCmdNone )
 {
 HandleAIWCommandL(aCommandId, currDownload);
 return;
 }
 switch ( aCommandId )
 {
 case EAknSoftkeyOpen: // handle middlesoft key
 {
 // First close the downloads list.
 CancelDisplayingDownloadsList();
 CLOG_WRITE(" CancelDisplayingDownloadsList OK");
 			if(iProgressiveDownload)
 			{
 // check if it's pd supported
 TBool isPdSupported = EFalse;
 // Get the PD player application's UID for the download
 TUid pdPlayerUid = { 0 };
 HBufC8* contentType = iUiUtils->ContentTypeL( currDownload, ETrue, KFirstMoIndex  );
 TDataType dataType( *contentType );
 delete contentType;
 contentType = NULL;
 CDocumentHandler* docHandler = CDocumentHandler::NewLC();
 isPdSupported = docHandler->CanHandleProgressivelyL( dataType, pdPlayerUid );
 CleanupStack::PopAndDestroy( docHandler ); // docHandler
 if ( isPdSupported && iUiUtils->IsNetworkPdCompatibleL() )
 {
 // Get the UI data for the current download
 TDownloadUiData& dlData = iListModel->DlUiData( aDialog.CurrentItemIndex() );
 TInt32 state( dlData.iProgressState );
 TBool isProgressively = ETrue;
 if ( state == EHttpProgContentFileMoved || state == EHttpProgContentFileMovedAndDestFNChanged )
 {
 // this will be used to tell multimedia app that content file
 // has already been moved, and it does not need to attach
 // to download - it can just read completed download from
 // filesystem.
 isProgressively = EFalse;
 }
 // First close the downloads list.
-CancelDisplayingDownloadsList();
+if ( state != EHttpProgMovingContentFile )
-iUiUtils->LaunchPdAppL(currDownload, isProgressively);
+{
-}
+CancelDisplayingDownloadsList();
-else
+iUiUtils->LaunchPdAppL(currDownload, isProgressively);
+}
+}
+else
 {
 iUiUtils->HandleContentL( currDownload, *iExtension );
 CLOG_WRITE("HandleContentL OK");
 }
 			}
 		else
 			{
 	    iUiUtils->HandleContentL( currDownload, *iExtension );
 	        CLOG_WRITE("HandleContentL OK");
 			}
 break;
 }
 // First close the downloads list.
 CancelDisplayingDownloadsList();
 CLOG_WRITE(" CancelDisplayingDownloadsList OK");
 iUiUtils->HandleContentL( currDownload, *iExtension );
 CLOG_WRITE("HandleContentL OK");
 // After the termination of the handler, download is removed
 // from the list of downloads in NotifyHandlerExitL().
 break;
 }
 case EDownloadsListCmdPlay:
 {
 			#ifdef __DMGR_PD_TESTHARNESS
 // First close the downloads list.
 CancelDisplayingDownloadsList();
 				iUiUtils->TestLaunchPdAppL(currDownload);
 			#else
 				// Get the UI data for the current download
 TDownloadUiData& dlData = iListModel->DlUiData( aDialog.CurrentItemIndex() );
 TInt32 state( dlData.iProgressState );
 TBool isProgressively = ETrue;
 if ( state == EHttpProgContentFileMoved || state == EHttpProgContentFileMovedAndDestFNChanged )
 {
 // this will be used to tell multimedia app that content file
 // has already been moved, and it does not need to attach
 // to download - it can just read completed download from
 // filesystem.
 isProgressively = EFalse;
 }
 // First close the downloads list.
 CancelDisplayingDownloadsList();
 					if (iUiUtils->IsNetworkPdCompatibleL() )
 						{
 						}
 			#endif	//__DMGR_PD_TESTHARNESS
 break;
 }
 case EDownloadsListCmdSave:
 {
 TBool saved = iUiUtils->SaveContentL( currDownload );
 if ( saved )
 {
 // Remove the download from the Downloads List to
 // avoid confusion...
 DeleteDownloadL( currDownload );
 }
 	        // The save (moving) procedure is asynchronous!
 	        // CUserInteractionsEventHandler handles
 	        // EHttpDlCompleted/EHttpProgMovingContentFile and
 	        // EHttpDlCompleted/EHttpProgContentFileMoved.
 break;
 }
 case EDownloadsListCmdDelete:
 {
 // Retrieve the full path to filename before deletion
 // this way we check if the the actuall content file was deleted or not,
 // if not, we will manually delete it
 HBufC* fileName = HBufC::NewLC( KMaxPath );
 TPtr fileNamePtr = fileName->Des();
 User::LeaveIfError
 ( currDownload.GetStringAttribute( EDlAttrDestFilename, fileNamePtr ) );
 User::LeaveIfError(fs.Connect());
 CleanupClosePushL(fs);
 TFindFile file(fs);
 TPtrC ptr(KNullDesC);
 TInt found = file.FindByPath(fileNamePtr1,&ptr); //when second parameter to the API is Null then the it searches for the file in the Dir specified in the first parameter
+TBool isFileOpen(EFalse);
+TInt fileopenstatus = fs.IsFileOpen(fileNamePtr1,isFileOpen);
 CleanupStack::PopAndDestroy(&fs);
 CleanupStack::PopAndDestroy(fileName1);
+if(fileopenstatus ==KErrNone && isFileOpen)
+User::Leave(KErrInUse);
 // Delete in DMgr
 TBool deleted = iUiUtils->DeleteWithUserConfirmL( currDownload );
 if ( deleted )
 {
 if(!iUiUtils->IsCodDownload())
 HBufC* infoPrompt = StringLoader::LoadLC( R_DMUL_ERROR_FILE_NOT_FOUND);
 CAknInformationNote* note = new(ELeave)  CAknInformationNote();
 note->ExecuteLD(*infoPrompt);
 CleanupStack::PopAndDestroy(infoPrompt);
 }
 			   // Do not wait until the delete event is reported through the
 			   // observer callback, but update the list right now,
 			   // so the user will not be able to access and modify an already
 			   // deleted download:
 			   DeleteDownloadL( currDownload );
 			   TBool result( EFalse );
 			   RFs rfs;
 			       result = BaflUtils::DeleteFile( rfs, fileNamePtr );
 			       }
 			   CleanupStack::PopAndDestroy( &rfs );
 			   // Notify Media Gallery about new media file
 			#ifdef BRDO_APP_GALLERY_SUPPORTED_FF
 			   CMGXFileManager* mgFileManager = MGXFileManagerFactory::NewFileManagerL(
 			       CEikonEnv::Static()->FsSession() );
 			   if( fileNamePtr.Length() > 0 )
 			       {
 			       TRAP_IGNORE( mgFileManager->UpdateL( fileNamePtr ) );
 			       }
 			   else
 			       {
 			       TRAP_IGNORE( mgFileManager->UpdateL() );
 			       }
 			   delete mgFileManager;
 			   mgFileManager = NULL;
 			 #else
 			  if( fileNamePtr.Length() > 0 )
 			       {
 			       TRAP_IGNORE( iUiUtils->UpdateDCFRepositoryL( fileNamePtr ) );
 			       }
 			 #endif
 	}
 else
 	           	{
 	           	DeleteDownloadL( currDownload );
 	           	}
 			 }
 CleanupStack::PopAndDestroy( fileName );
 break;
 }
 for ( TInt i = 0; i < count; ++i )
 {
 RHttpDownload& download = iListModel->Download(i);
 TInt32 dlState(0);
 TInt err = download.GetIntAttribute( EDlAttrState, dlState );
 //Changes for the bug JERI-7P8CF2
 //Changes made in the server side to fix the video center receiving unexpected events
 //Reassigning these events back to the changes done in server side
 if( !err && dlState  == EHttpDlCompleted )
 		            {
 		            }
 else if( !err && dlState  == EHttpDlFailed )
 		            {
 		    	     dlState  = EHttpDlMultipleMOFailed;
 		            }
 if ( !err && ( dlState == EHttpDlPaused || dlState == EHttpDlMultipleMOFailed ) )
 {
 download.Start(); // return value is ignored.
 }
 }
 	            if (err != KErrNone)
 	            	{
 	            	iIsCancelInProgress = EFalse;
 	            	User::LeaveIfError(err);
 	            	}
 	            if ( cancelled )
 	                {
-	                DeleteDownloadL( currDownload );
+DeleteDownloadL( currDownload );
+#ifdef BRDO_SINGLE_CLICK_ENABLED_FF
+TInt currentItemIndex = aDialog.CurrentItemIndex();
+if (currentItemIndex != -1)
+{
+TInt Inprogress = iListModel->DownloadsCount
+( MASKED_DL_STATE(EHttpDlCreated) |
+MASKED_DL_STATE(EHttpDlPaused) |
+MASKED_DL_STATE(EHttpDlInprogress) |
+MASKED_DL_STATE(EHttpDlMultipleMOFailed));
+if ( Inprogress > 1 )
+{
+aDialog.ButtonGroupContainer()->MakeCommandVisible( EAknSoftkeyOptions, ETrue );
+}
+else
+{
+aDialog.ButtonGroupContainer()->MakeCommandVisible( EAknSoftkeyOptions, EFalse );
+}
+}
+#endif
 	                }
 	            iIsCancelInProgress = EFalse;
 	}
 break;
 }
 case EDownloadsListCmdCancelAll:
 	{
 if (!iIsCancelInProgress)
 	{
 	iIsCancelInProgress = ETrue;
 	break;
 	}
 case EDownloadsListCmdGallery:
 {
 #ifdef BRDO_APP_GALLERY_SUPPORTED_FF
 TVwsViewId id = TVwsViewId(
 TUid::Uid( KMediaGalleryUID3 ),
 TUid::Uid( KMediaGalleryListViewUID ) );
 // By default, custom message is empty
 TPtrC8 customMessage( KNullDesC8 );
 CEikonEnv::Static()->EikAppUi()->ActivateViewL(
 id,
 TUid::Uid( KMediaGalleryCmdMoveFocusToAllFilesTab ),
 customMessage );
 #endif
 break;
 }
 case EDownloadsListCmdFileManager:
 {
 if ( iPlatformSupportsGallery )
 {
 	LaunchFileManagerApplication();
 }
 else
 {
 	CAiwServiceHandler* serviceHandler = CAiwServiceHandler::NewL();
 serviceHandler->AttachL( R_DMUL_FILEMANAGER_AIW_INTEREST );
 CAiwGenericParamList* inParams = CAiwGenericParamList::NewLC();
 //get the destination file path
 HBufC* fileName = HBufC::NewLC( KMaxPath );
 TPtr fileNamePtr = fileName->Des();
 User::LeaveIfError ( currDownload.GetStringAttribute( EDlAttrDestFilename, fileNamePtr ) );
 // Locate the last '\\' character and remove the file name so that we will get the folder name
 TInt len = fileNamePtr.LocateReverse('\\');
 TPtr ptr = fileNamePtr.LeftTPtr(len + 1);
 // Append the directory name to be opened
 inParams->AppendL(TAiwGenericParam(EGenericParamDir, TAiwVariant( ptr ) ) );
 //Append the sort method
 inParams->AppendL(TAiwGenericParam(EGenericParamDir, TAiwVariant( KMostRecentSort ) ) );
 //Append to define whether to open in standalone mode
 inParams->AppendL(TAiwGenericParam(EGenericParamDir, TAiwVariant( KLauchStandAlone ) ) );
 TRAPD( err, serviceHandler->ExecuteServiceCmdL( KAiwCmdEdit, *inParams, serviceHandler->OutParamListL() ));
 	   		CleanupStack::PopAndDestroy( fileName );
 	CleanupStack::PopAndDestroy( inParams );
 	    delete serviceHandler;
 	    //if there is any error, open the file manager in root folder
 if (err != KErrNone)
 	        {
 	        LaunchFileManagerApplication();
 		    }
 }
 break;
 }
 default:
 {
 break;
 }
 }
 }
 // -----------------------------------------------------------------------------
 // CDownloadMgrUiDownloadsList::LaunchFileManagerApplication
 // -----------------------------------------------------------------------------
 //
 void CDownloadMgrUiDownloadsList::LaunchFileManagerApplication()
 {
 TApaTaskList taskList( CEikonEnv::Static()->WsSession() );
 CRepository *repository=CRepository::NewL(KCRUidBrowser);
 TInt fileManagerId;
 User::LeaveIfError(repository->Get(KFileManagerUid , fileManagerId ));
 TUid id = TUid::Uid(fileManagerId);
 TApaTask task = taskList.FindApp( id );
 if ( task.Exists() )
 {
 task.BringToForeground();
 }
 else
 {
 RApaLsSession appArcSession;
 User::LeaveIfError( appArcSession.Connect() );
 CleanupClosePushL( appArcSession );
 TThreadId id1;
 User::LeaveIfError( appArcSession.StartDocument( KNullDesC, id, id1 ) );
 CleanupStack::PopAndDestroy( &appArcSession );
 }
 }
 // -----------------------------------------------------------------------------
 // CDownloadMgrUiDownloadsList::DynInitMenuPaneL
 // -----------------------------------------------------------------------------
 //
 void CDownloadMgrUiDownloadsList::DynInitMenuPaneL( CDownloadsListDlg& aDialog,
 TInt aResourceId,
 CEikMenuPane* aMenuPane )
 {
 CLOG_ENTERFN("CDownloadMgrUiDownloadsList::DynInitMenuPaneL");
 __ASSERT_DEBUG( iExtension->IsDialogVisible(), Panic( EUiLibPanNull ) );
 TInt currentItemIndex = aDialog.CurrentItemIndex();
 __ASSERT_DEBUG( 0 <= currentItemIndex, Panic( EUiLibPanDLNegItemIndex ) );
 RHttpDownload& currDownload = iListModel->Download( currentItemIndex );
 CLOG_WRITE_FORMAT(" currDownload: 0x%x",&currDownload);
 // Get the UI data for the current download
 TDownloadUiData& dlData = iListModel->DlUiData( aDialog.CurrentItemIndex() );
 TInt32 state( dlData.iDownloadState );
 CLOG_WRITE_FORMAT(" state: %d",state);
 // The moved state is only a temporary state - the server
 // sets the download's original state back right after it,
 // thus we query the state again:
 if ( state == EHttpDlMoved )
 {
 User::LeaveIfError( currDownload.GetIntAttribute( EDlAttrState, state ) );
 //Changes for the bug JERI-7P8CF2
 //Changes made in the server side to fix the video center receiving unexpected events
 //Reassigning these events back to the changes done in server side
 if( state  == EHttpDlCompleted )
 		        {
 		        }
 else if(state  == EHttpDlFailed )
 		        {
 		        state  = EHttpDlMultipleMOFailed;
 		        }
 CLOG_WRITE_FORMAT(" state re-query: %d",state);
 }
 __ASSERT_DEBUG( state != EHttpDlMoved, Panic( EUiLibPanStateIsStillMoved ) );
 TBool wasCompleted   = state == EHttpDlMultipleMOCompleted;
 // Get if it's theme
 TInt isThemeType = 0;
 HBufC8* contentType = HBufC8::NewLC(KMaxContentTypeLength);
 TPtr8 contentTypePtr = contentType->Des();
 User::LeaveIfError
 ( currDownload.GetStringAttribute( EDlAttrContentType, contentTypePtr ) );
 isThemeType = !contentType->Compare(KSisxContentType);
 CleanupStack::PopAndDestroy( contentType );
 if ( aResourceId == R_DMUL_DOWNLOADSLIST_MENU )
 {
 __ASSERT_DEBUG( 0<iListModel->Count(), Panic( EUiLibPanOptionsShownWhileNoDownloads ) );
-TBool isCreated     = state == EHttpDlCreated;
+// The fix of PHAN-6KVK5R makes this line no longer necessary
-// The fix of PHAN-6KVK5R makes this line no longer necessary
 // TBool isInProgress  = state == EHttpDlInprogress;
-TBool isPaused      = state == EHttpDlPaused;
 TBool isCompleted   = state == EHttpDlMultipleMOCompleted;
-TBool isFailed      = state == EHttpDlMultipleMOFailed;
 TBool isDrmDownload = EFalse;
 TBool isDrmRightsOnPhone = EFalse;
 TBool isPreviewRights = EFalse;
 // OMA DRM information is used only in case of completed downloads
 if ( isCompleted )
 }
 TBool s60Supported( EFalse );
 TBool gallerySupported( EFalse );
 s60Supported = iUiUtils->IsContentTypeSupportedL( dlData.iContentType );
 gallerySupported = CDownloadUtils::IsGallerySupported(dlData.iContentType);
 CLOG_WRITE_FORMAT(" s60Supported: %d",s60Supported);
 CLOG_WRITE_FORMAT(" gallerySupported: %d",gallerySupported);
 TBool isCodDownload( EFalse );
 TInt err = currDownload.GetBoolAttribute( EDlAttrCodDownload, isCodDownload );
 CLOG_WRITE_FORMAT(" EDlAttrCodDownload err: %d",err);
 TBool isCodPdDownload( EFalse );
 err = currDownload.GetBoolAttribute( EDlAttrCodPdAvailable, isCodPdDownload );
 CLOG_WRITE_FORMAT(" EDlAttrCodPdAvailable err: %d",err);
 // Get if it can be handled progressively
 TBool canProgHandled = EFalse;
 TUid pdPlayerUid = { 0 };
 HBufC8* contentType = iUiUtils->ContentTypeL( currDownload, ETrue );
 TDataType dataType( *contentType );
 delete contentType;
 contentType = NULL;
 CDocumentHandler* docHandler = CDocumentHandler::NewLC();
 canProgHandled = docHandler->CanHandleProgressivelyL( dataType, pdPlayerUid );
 CleanupStack::PopAndDestroy( docHandler ); // docHandler
+#ifndef BRDO_SINGLE_CLICK_ENABLED_FF
+TBool isCreated     = state == EHttpDlCreated;
+TBool isPaused      = state == EHttpDlPaused;
+TBool isFailed      = state == EHttpDlMultipleMOFailed;
 //delete open file manager when download is not complete
 if( !(isCompleted))
 {
 aMenuPane->DeleteMenuItem( EDownloadsListCmdFileManager );
 }
 // For any gallery supported download,  "go to gallery" option should be displayed in the download list option when the download completes
 if ( (!( isCompleted && s60Supported && gallerySupported ) ) || (!iPlatformSupportsGallery) )
 {
 			aMenuPane->DeleteMenuItem( EDownloadsListCmdGallery );
 		}
 if ( !( isCompleted && s60Supported && gallerySupported &&
 ( !isDrmDownload || ( isDrmDownload && isDrmRightsOnPhone ) ) ) )
 {
 aMenuPane->DeleteMenuItem( EDownloadsListCmdUseAs );
 			}
 	    else
 	        {
 	        TInt32 numMediaObjects = 0;
 User::LeaveIfError( currDownload.GetIntAttribute( EDlAttrNumMediaObjects, numMediaObjects ) );
 	        if (numMediaObjects > KFirstMoIndex)
 	        {
 	            aMenuPane->DeleteMenuItem( EDownloadsListCmdUseAs );
 	            }
 	        }
 if( iProgressiveDownload || isCompleted )
 {
 if ( canProgHandled )
 {
 aMenuPane->DeleteMenuItem( EDownloadsListCmdOpen );
 if (isCodDownload && !isCompleted )
 {
 if ( !( gallerySupported && canProgHandled  && isCodPdDownload &&
 ( !isDrmDownload || ( isDrmDownload && isDrmRightsOnPhone ) ) ) || (isPaused || isFailed))
 aMenuPane->DeleteMenuItem( EDownloadsListCmdPlay );
 }
 else
 {
 if ( !( gallerySupported && canProgHandled &&
 ( !isDrmDownload || ( isDrmDownload && isDrmRightsOnPhone ))) || (isPaused || isFailed))
 aMenuPane->DeleteMenuItem( EDownloadsListCmdPlay );
 }
 }
 else
 {
 aMenuPane->DeleteMenuItem( EDownloadsListCmdPlay );
 if ( !( isCompleted && ( s60Supported ) &&
 ( !isDrmDownload || ( isDrmDownload && isDrmRightsOnPhone ) ) ) )
 {
 aMenuPane->DeleteMenuItem( EDownloadsListCmdOpen );
 }
 //there should not be open in menu when download is not complete and file is not supported by s60  or Gallery
 /*  else if( isCompleted && ( !s60Supported && !gallerySupported))
 {
 aMenuPane->DeleteMenuItem( EDownloadsListCmdOpen );
 }*/
 }
 }
 else // if iProgressiveDownload == EFalse
 {
 aMenuPane->DeleteMenuItem( EDownloadsListCmdPlay );
 if ( !( isCompleted && s60Supported &&
 ( !isDrmDownload || ( isDrmDownload && isDrmRightsOnPhone ) ) ) )
 {
 aMenuPane->DeleteMenuItem( EDownloadsListCmdOpen );
 }
 else if( isCompleted && !s60Supported && gallerySupported)
 {
 aMenuPane->DeleteMenuItem( EDownloadsListCmdOpen );
 }
 }
 // ELFG-732DK3: There is no need to have save option since it's already saved
 aMenuPane->DeleteMenuItem( EDownloadsListCmdSave );
 if ( !( isCompleted ) )
 {
 aMenuPane->DeleteMenuItem( EDownloadsListCmdDelete );
 }
 else
 */
 if ( !( isCreated || isPaused || isFailed ) )
 {
 aMenuPane->DeleteMenuItem( EDownloadsListCmdResume );
 }
 // Count paused downloads. Note that Creates and Failed downloads
 // are also considered as Paused, and they can be resumed.
 TInt pausedCount = iListModel->DownloadsCount
 ( MASKED_DL_STATE(EHttpDlCreated) |
 MASKED_DL_STATE(EHttpDlPaused) |
 MASKED_DL_STATE(EHttpDlMultipleMOFailed) );
 CLOG_WRITE_FORMAT(" paused count: %d",pausedCount);
 //
 if ( !( 1 < pausedCount ) )
 {
 aMenuPane->DeleteMenuItem( EDownloadsListCmdResumeAll );
 }
 TInt downloadCount = iListModel->DownloadsCount
 ( MASKED_DL_STATE(EHttpDlCreated) |
 MASKED_DL_STATE(EHttpDlInprogress)|
 MASKED_DL_STATE(EHttpDlPaused) );
 CLOG_WRITE_FORMAT(" download count: %d",downloadCount);
 if ( !( 1 < downloadCount ) )
 {
 aMenuPane->DeleteMenuItem( EDownloadsListCmdCancelAll );
 }
 	if ( iPlatformSupportsGallery )
 	    {
 		if ( isCompleted && gallerySupported && s60Supported )
 {
 aMenuPane->DeleteMenuItem( EDownloadsListCmdFileManager );
 }
-	    }
+}
-}
+#else
+// Count paused downloads. Note that Creates and Failed downloads
-if ( wasCompleted && !isThemeType )
+// are also considered as Paused, and they can be resumed.
-{
+TInt pausedCount = iListModel->DownloadsCount
-InitializeAIWPlugInMenusL( aResourceId, aMenuPane, currDownload );
+( MASKED_DL_STATE(EHttpDlCreated) |
+MASKED_DL_STATE(EHttpDlPaused) |
+MASKED_DL_STATE(EHttpDlMultipleMOFailed) );
+CLOG_WRITE_FORMAT(" paused count: %d",pausedCount);
+//
+if ( !( 1 < pausedCount ) )
+{
+aMenuPane->DeleteMenuItem( EDownloadsListCmdResumeAll );
+}
+TInt downloadCount = iListModel->DownloadsCount
+( MASKED_DL_STATE(EHttpDlCreated) |
+MASKED_DL_STATE(EHttpDlInprogress)|
+MASKED_DL_STATE(EHttpDlPaused) );
+CLOG_WRITE_FORMAT(" download count: %d",downloadCount);
+if ( !( 1 < downloadCount ) )
+{
+aMenuPane->DeleteMenuItem( EDownloadsListCmdCancelAll );
+}
+#endif
+}
+if ( wasCompleted && !isThemeType )
+{
+InitializeAIWPlugInMenusL( aResourceId, aMenuPane, currDownload );
 }
 CLOG_LEAVEFN("CDownloadMgrUiDownloadsList::DynInitMenuPaneL");
 }
+#ifdef BRDO_SINGLE_CLICK_ENABLED_FF
+void CDownloadMgrUiDownloadsList::AIWPlugInMenusL(TInt aResourceId,CEikMenuPane* aMenuPane)
+{
+if( !iAIWServiceHandler )
+{
+AttachAIWInterestL();
+}
+RHttpDownload& currDownload = iListModel->Download( 0 );
+InitializeAIWPlugInMenusL( aResourceId, aMenuPane, currDownload );
+}
+#endif
 // -----------------------------------------------------------------------------
 // CDownloadMgrUiDownloadsList::OfferKeyEventL
 // -----------------------------------------------------------------------------
 //
 TKeyResponse CDownloadMgrUiDownloadsList::OfferKeyEventL
 // -----------------------------------------------------------------------------
 // FindDlUiData
 // -----------------------------------------------------------------------------
 //
 inline TDownloadUiData* FindDlUiData( CDownloadsListArray& aListModel,
 RHttpDownload& aDownload,
 TInt& aIndex )
 {
 TInt err = aListModel.Find( aDownload, aIndex );
 if ( err == KErrNotFound )
 else
 {
 return &( aListModel.DlUiData( aIndex ) );
 }
 };
 // -----------------------------------------------------------------------------
 // CDownloadMgrDownloadsList::AttachAIWInterestL
 // -----------------------------------------------------------------------------
 //
 void CDownloadMgrUiDownloadsList::AttachAIWInterestL()
 // ----------------------------------------------------
 // CDownloadMgrUiDownloadsList::HandleAIWCommandL(TInt aCommand, RHttpDownload& aDownload)
 // ----------------------------------------------------
 //
 void CDownloadMgrUiDownloadsList::HandleAIWCommandL(TInt aCommand, RHttpDownload& aDownload)
-{
-// The command is an AIW command
+{
+//Check if file exists
+HBufC* fileName = HBufC::NewLC( KMaxPath );
+TPtr fileNamePtr = fileName->Des();
+User::LeaveIfError( aDownload.GetStringAttribute( EDlAttrDestFilename, fileNamePtr ) );
+	if(!iUiUtils->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);
+return;
+	    }
+CleanupStack::PopAndDestroy(fileName);
+// The command is an AIW command
 CAiwGenericParamList& params = iAIWServiceHandler->InParamListL();
 TInt aiwOptions( 0 );
 ProvideInputParametersL( params, aiwOptions, aDownload );
 CAiwGenericParamList& output = iAIWServiceHandler->OutParamListL();
 TAiwVariant fileNameVariant( fileNamePtr );
 TAiwGenericParam genericParamFileName( EGenericParamFile, fileNameVariant );
 	aParams.AppendL( genericParamFileName );
 	HBufC* contentType = HBufC::NewLC(KMaxContentTypeLength);
 	TPtr contentTypePtr = contentType->Des();
 User::LeaveIfError
 ( aDownload.GetStringAttribute( EDlAttrContentType, contentTypePtr ) );
 fileNameVariant.Set(contentTypePtr);
 TAiwGenericParam genericParamMimeType( EGenericParamMIMEType, fileNameVariant );
 aParams.AppendL( genericParamMimeType );
 CleanupStack::PopAndDestroy( contentType );
 CleanupStack::PopAndDestroy( fileName );
 }
 // -----------------------------------------------------------------------------
 // CDownloadMgrUiDownloadsList::InitializeAIWPlugInMenusL
 // -----------------------------------------------------------------------------
 //
 void CDownloadMgrUiDownloadsList::InitializeAIWPlugInMenusL( TInt aResourceId,
 {
 iDownloadListHide = aHide;
 }
 #ifdef __WINS__
 #include <commdb.h>
-#include <aknlists.h>
+#include <AknLists.h>
 // ----------------------------------------------------------------------------
 // AskIapId(TUint32& aId)
 // Ask IAP id from the user. Used due to efficiency only on WINS* platforms.
 // ----------------------------------------------------------------------------
 //
 RArray<TUint32> idArray;
 CleanupClosePushL( idArray );
 CDesCArrayFlat* nameArray = new (ELeave) CDesCArrayFlat(16);
 CleanupStack::PushL( nameArray );
 // Get IAP names and ids from the database
 CCommsDatabase* TheDb = CCommsDatabase::NewL( EDatabaseTypeIAP );
 CleanupStack::PushL( TheDb );
 TheDb->ShowHiddenRecords();
 TInt res = view->GotoFirstRecord();
 while( res == KErrNone )
 {
 view->ReadTextL( TPtrC(COMMDB_NAME), name );
 view->ReadUintL( TPtrC(COMMDB_ID), id );
 idArray.Insert( id, 0 );
 nameArray->InsertL( 0, name );
 res = view->GotoNextRecord();
 RDebug::Print(_L("IAP name, id: %S, %d"), &name, id);
 }
 CleanupStack::PopAndDestroy( view ); // view
 CleanupStack::PopAndDestroy( TheDb ); // TheDb
 // Create listbox and PUSH it.
 CEikTextListBox* list = new(ELeave) CAknSinglePopupMenuStyleListBox;
 CleanupStack::PushL( list );
 // Create popup list and PUSH it.
 CAknPopupList* popupList = CAknPopupList::NewL(
 list, R_AVKON_SOFTKEYS_OK_EMPTY__OK,
 AknPopupLayouts::EMenuWindow);
 CleanupStack::PushL( popupList );
 // initialize listbox.
 list->ConstructL( popupList, CEikListBox::ELeftDownInViewRect );
 list->CreateScrollBarFrameL( ETrue );
 list->ScrollBarFrame()->SetScrollBarVisibilityL(
 CEikScrollBarFrame::EOff,
 CEikScrollBarFrame::EAuto );
 // Set listitems.
 CTextListBoxModel* model = list->Model();
 model->SetItemTextArray( nameArray );
 model->SetOwnershipType( ELbmDoesNotOwnItemArray );
 // Set title
 popupList->SetTitleL( _L("Select IAP:") );
 // Show popup list.
 TInt popupOk = popupList->ExecuteLD();
 CleanupStack::Pop( popupList ); // popupList
 if ( popupOk )
 {
 TInt index = list->CurrentItemIndex();
 aId = idArray[index];
 }
 CleanupStack::PopAndDestroy( 3, &idArray );  // list, nameArray, idArray
 return popupOk;
 }
 #endif // #ifdef __WINS__
 /* End of file. */

branch	RCL_3
changeset 94	919f36ff910f
parent 93	79859ed3eea9