browserutilities/downloadmgr/DownloadMgrUiLib/Src/CDownloadMgrUiUserInteractions.cpp
/*
* Copyright (c) 2002-2004 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Supports user interaction dialogs for downloads
*
*/
// INCLUDE FILES
#include <cdownloadmgruiuserinteractions.h>
#include "CUserInteractionsUtils.h"
#include <cdownloadmgruidownloadslist.h>
#include <cdownloadmgruilibregistry.h>
#include "UserInteractionsEventHandler.h"
#include "AsyncEventHandlerArray.h"
#include "UiLibLogger.h"
#include "DMgrUiLibPanic.h"
#include "MDownloadHandlerObserver.h"
#include <e32std.h>
#include <e32def.h>
#include <StringLoader.h>
#include <DownloadMgrUiLib.rsg>
#include <AknQueryDialog.h>
#include <avkon.rsg>
#include <eikon.hrh>
#include <eikappui.h>
#include <apparc.h>
#include <AknServerApp.h>
#include <DRMCommon.h>
// LOCAL CONSTANTS AND MACROS
const TInt KPostponedDownloadsGranularity = 1;
/**
* Extension class.
*/
NONSHARABLE_CLASS( CUserInteractionsExtension ) : public CBase,
public MDownloadHandlerObserver
{
public: // Constructors and destructor
/**
* Two-phased constructor.
*/
static CUserInteractionsExtension* NewL
( CDownloadMgrUiUserInteractions& aUserInteractions );
/**
* Destructor.
*/
virtual ~CUserInteractionsExtension();
public: // New functions
/**
* Postpone handling the given COD download. The download is placed to a
* LIFO queue. Call SchedulePostponedDownloadL() to invoke the handling
* of a download in the list.
* @param aDownload The download to be postponed.
*/
void PostponeCodHandlingL( RHttpDownload& aDownload );
/**
* Check if the given download is postponed.
* @param aDownload The download in question.
* @return true/false.
*/
TBool IsPostponed( RHttpDownload& aDownload ) const;
/**
* Schedule a postponed download for running.
*/
void SchedulePostponedDownloadL();
protected: // Constructors
/**
* C++ default constructor.
*/
CUserInteractionsExtension( CDownloadMgrUiUserInteractions& aUserInteractions );
/**
* By default Symbian 2nd phase constructor is private.
*/
void ConstructL();
protected: // From MDownloadHandlerObserver
void NotifyHandlerExit( RHttpDownload* aDownload, TInt aReason );
public: // Data
CDownloadMgrUiUserInteractions& iUserInteractions;
TBuf<KMaxPath> iFileName; ///< Buffer for file name.
// Attributes
TBool iIsCompletedStateHandled; ///< Event handling preferencies
TBool iSuppressDownloadConfirmation;
CArrayPtrFlat< RHttpDownload >* iPostponedCodDownloads; ///< Owned.
};
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CUserInteractionsExtension::CUserInteractionsExtension
// -----------------------------------------------------------------------------
//
CUserInteractionsExtension::CUserInteractionsExtension
( CDownloadMgrUiUserInteractions& aUserInteractions )
: iUserInteractions( aUserInteractions ),
iFileName( KNullDesC ),
iIsCompletedStateHandled( ETrue )
{
}
// -----------------------------------------------------------------------------
// CUserInteractionsExtension::ConstructL
// -----------------------------------------------------------------------------
//
void CUserInteractionsExtension::ConstructL()
{
CLOG_ENTERFN("CUserInteractionsExtension::ConstructL");
CLOG_LEAVEFN("CUserInteractionsExtension::ConstructL");
}
// -----------------------------------------------------------------------------
// CUserInteractionsExtension::NewL
// -----------------------------------------------------------------------------
//
CUserInteractionsExtension* CUserInteractionsExtension::NewL
( CDownloadMgrUiUserInteractions& aUserInteractions )
{
CUserInteractionsExtension* self =
new (ELeave) CUserInteractionsExtension( aUserInteractions );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop();
return self;
}
// Destructor
CUserInteractionsExtension::~CUserInteractionsExtension()
{
CLOG_ENTERFN("CUserInteractionsExtension::~CUserInteractionsExtension");
delete iPostponedCodDownloads;
CLOG_WRITE(" iPostponedCodDownloads OK");
CLOG_LEAVEFN("CUserInteractionsExtension::~CUserInteractionsExtension");
}
// -----------------------------------------------------------------------------
// CUserInteractionsExtension::PostponeCodHandlingL
// -----------------------------------------------------------------------------
//
void CUserInteractionsExtension::PostponeCodHandlingL( RHttpDownload& aDownload )
{
CLOG_ENTERFN("CUserInteractionsExtension::PostponeCodHandlingL");
if ( !iPostponedCodDownloads )
{
iPostponedCodDownloads = new (ELeave) CArrayPtrFlat< RHttpDownload >
( KPostponedDownloadsGranularity );
CLOG_WRITE(" new OK");
}
// Insert download at the end of the array
iPostponedCodDownloads->AppendL( &aDownload );
CLOG_LEAVEFN("CUserInteractionsExtension::PostponeCodHandlingL");
}
// -----------------------------------------------------------------------------
// CUserInteractionsExtension::IsPostponed
// -----------------------------------------------------------------------------
//
TBool CUserInteractionsExtension::IsPostponed( RHttpDownload& aDownload ) const
{
CLOG_ENTERFN("CUserInteractionsExtension::IsPostponed");
TInt index( KErrNotFound );
TKeyArrayFix cmpKey( 0, ECmpTUint32 );
TInt err = KErrNotFound;
if ( iPostponedCodDownloads )
{
err = iPostponedCodDownloads->Find( &aDownload, cmpKey, index );
CLOG_WRITE_FORMAT(" err: %d", err);
CLOG_WRITE_FORMAT(" index: %d", index);
}
CLOG_LEAVEFN("CUserInteractionsExtension::IsPostponed");
return !err;
}
// -----------------------------------------------------------------------------
// CUserInteractionsExtension::SchedulePostponedDownloadL
// -----------------------------------------------------------------------------
//
void CUserInteractionsExtension::SchedulePostponedDownloadL()
{
CLOG_ENTERFN("CUserInteractionsExtension::SchedulePostponedDownloadL");
// Start next download handling
if ( iPostponedCodDownloads )
{
TInt postponedCodDlCount = iPostponedCodDownloads->Count();
CLOG_WRITE_FORMAT(" postponedCodDlCount: %d", postponedCodDlCount);
if ( postponedCodDlCount )
{
// Restart the first COD download in the list
RHttpDownload* codDl = (RHttpDownload*) iPostponedCodDownloads->At(0);
TInt errorRet = codDl->Start();
CLOG_WRITE_FORMAT(" errorRet: %d", errorRet);
User::LeaveIfError( errorRet );
// Remove the download from the lifo list, but do not delete it!
iPostponedCodDownloads->Delete(0);
}
}
CLOG_LEAVEFN("CUserInteractionsExtension::SchedulePostponedDownloadL");
}
// -----------------------------------------------------------------------------
// CUserInteractionsExtension::NotifyHandlerExit
// -----------------------------------------------------------------------------
//
void CUserInteractionsExtension::NotifyHandlerExit( RHttpDownload* aDownload,
TInt aReason )
{
CLOG_ENTERFN("CUserInteractionsExtension::NotifyHandlerExit");
CLOG_WRITE_FORMAT(" aReason: %d", aReason);
// Delete the download if the handler terminated without error
if ( aReason == KErrNone || aReason == EEikCmdExit || aReason == EAknCmdExit )
{
if ( aDownload )
{
/* return value is ignored */aDownload->Delete();
CLOG_WRITE(" Delete OK");
}
}
// Propagate the event to the registered observer, too
if ( iUserInteractions.iServerAppExitObserver != 0 )
{
CLOG_WRITE(" Propagating event...");
iUserInteractions.iServerAppExitObserver->HandleServerAppExit( aReason );
}
CLOG_LEAVEFN("CUserInteractionsExtension::NotifyHandlerExit");
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::CDownloadMgrUiUserInteractions
// -----------------------------------------------------------------------------
//
CDownloadMgrUiUserInteractions::CDownloadMgrUiUserInteractions
( CDownloadMgrUiLibRegistry& aRegistryModel )
: CDownloadMgrUiBase( aRegistryModel ),
iDlgActive ( EFalse ),
iProgressiveDownloadLaunched ( EFalse )
{
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::ConstructL
// -----------------------------------------------------------------------------
//
void CDownloadMgrUiUserInteractions::ConstructL()
{
CLOG_ENTERFN("CDownloadMgrUiUserInteractions::ConstructL");
BaseConstructL();
CLOG_WRITE(" BaseConstructL");
iExtension = CUserInteractionsExtension::NewL( *this );
CLOG_WRITE(" iExtension");
iUiUtils = CUserInteractionsUtils::NewL( *this, iRegistryModel );
CLOG_WRITE(" iUiUtils");
iEventHandlerArray = new(ELeave)CAsyncEventHandlerArray();
CLOG_WRITE(" iEventHandlerArray");
// Cancel the Soft Notifications belonging to this client
iUiUtils->CancelSoftNotifStndL
( TVwsViewId(iRegistryModel.ClientAppUid(),TUid::Null()),
TUid::Null(), KNullDesC8 );
iUiUtils->CancelSoftNotifEmbL
( TVwsViewId(iRegistryModel.ClientAppUid(),TUid::Null()),
TUid::Null(), KNullDesC8 );
CLOG_LEAVEFN("CDownloadMgrUiUserInteractions::ConstructL");
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::NewL
// -----------------------------------------------------------------------------
//
CDownloadMgrUiUserInteractions* CDownloadMgrUiUserInteractions::NewL
( CDownloadMgrUiLibRegistry& aRegistryModel )
{
CDownloadMgrUiUserInteractions* self =
new ( ELeave ) CDownloadMgrUiUserInteractions( aRegistryModel );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop();
return self;
}
// Destructor
CDownloadMgrUiUserInteractions::~CDownloadMgrUiUserInteractions()
{
CLOG_ENTERFN("CDownloadMgrUiUserInteractions::~CDownloadMgrUiUserInteractions");
delete iEventHandlerArray;
iEventHandlerArray = 0;
CLOG_WRITE(" iEventHandlerArray");
delete iUiUtils;
iUiUtils = 0;
CLOG_WRITE(" iUiUtils");
// iExtension should be the last deleted.
delete iExtension;
iExtension = 0;
CLOG_WRITE(" iExtension");
CLOG_LEAVEFN("CDownloadMgrUiUserInteractions::~CDownloadMgrUiUserInteractions");
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::OkToExitL
// -----------------------------------------------------------------------------
//
EXPORT_C
TBool CDownloadMgrUiUserInteractions::OkToExitL()
{
CLOG_ENTERFN("CDownloadMgrUiUserInteractions::OkToExitL");
TBool okToExit = EFalse;
TInt downloadCnt = iRegistryModel.DownloadCount();
CLOG_WRITE_FORMAT(" downloadCnt: %d", downloadCnt);
// do nothing if this is 0
if ( downloadCnt == 0 )
{
okToExit = ETrue;
CLOG_LEAVEFN("CDownloadMgrUiUserInteractions::OkToExitL");
return okToExit;
}
// will delete client's completed, not hidden downloads
THttpDownloadState state;
THttpProgressState progState;
TBool isHiddenDel = EFalse;
TBool isCodDownload( EFalse );
TBool isProg (EFalse);
// check if progressive download, if yes, will NOT delete from the list, otherwise will
const CDownloadArray& downloadsDel = iRegistryModel.DownloadMgr().CurrentDownloads();
for ( TInt i = downloadCnt - 1; i >= 0; --i )
{
RHttpDownload* dl = downloadsDel.At(i); // current download
dl->GetIntAttribute(EDlAttrState, (TInt32&)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 )
{
state = EHttpDlMultipleMOCompleted;
}
else if(state == EHttpDlFailed )
{
state = EHttpDlMultipleMOFailed;
}
if ( state == EHttpDlMultipleMOCompleted )
{
dl->GetBoolAttribute( EDlAttrHidden, isHiddenDel ); // return value ignored
dl->GetIntAttribute( EDlAttrProgressState, (TInt32&)progState );
dl->GetBoolAttribute( EDlAttrProgressive, isProg );
if ( (!isHiddenDel && ( progState == EHttpProgContentFileMoved || progState == EHttpProgContentFileMovedAndDestFNChanged )&& !isProg) )
{
User::LeaveIfError( dl->Delete() );
}
}
}
downloadCnt = iRegistryModel.DownloadCount();
// Client is intrested in only those downloads for that the
// media has not been removed or pausable (non-pausable downloads
// will be deleted).
TInt32 noMediaDownloads(0);
iRegistryModel.DownloadMgr().GetIntAttribute( EDlMgrNoMediaDls, noMediaDownloads );
CLOG_WRITE_FORMAT(" noMediaDownloads: %d", noMediaDownloads);
// Return value is ignored.
// If it returns an error, then 'noMediaDownloads' is considered 0.
// Count hidden downloads, too.
TInt32 hiddenDownloads = 0;
TBool isHidden;
const CDownloadArray& downloads = iRegistryModel.DownloadMgr().CurrentDownloads();
for ( TInt i = 0; i < downloadCnt; ++i )
{
RHttpDownload* dl = downloads.At(i); // current download
dl->GetBoolAttribute( EDlAttrHidden, isHidden ); // return value ignored
if ( isHidden )
{
++hiddenDownloads;
}
}
CLOG_WRITE_FORMAT(" hiddenDownloads: %d", hiddenDownloads);
// Check if there is progressively played download
TInt32 progressivelyPlayed = 0;
for ( TInt i = downloadCnt - 1; i >=0; --i )
{
RHttpDownload* dl = downloads.At(i); //current download
dl->GetBoolAttribute( EDlAttrProgressive, isProg );
if (isProg && state==EHttpDlMultipleMOCompleted)
{
progressivelyPlayed++;
break;
}
}
TBool isPausable;
for ( TInt i = 0; i < downloadCnt; ++i )
{
RHttpDownload* dl = downloads.At(i);
dl->GetBoolAttribute( EDlAttrPausable, isPausable );
if(!isPausable)
{
break;
}
}
downloadCnt = downloadCnt - noMediaDownloads - hiddenDownloads - progressivelyPlayed;
CLOG_WRITE_FORMAT(" downloads result: %d", downloadCnt);
if ( downloadCnt < 1 || isPausable)
{
okToExit = ETrue;
}
else
{
HBufC* prompt = StringLoader::LoadLC( downloadCnt==1 ?
R_DMUL_EXIT_CONF_SING : R_DMUL_EXIT_CONF_PLUR );
CAknQueryDialog* conf = CAknQueryDialog::NewL();
conf->PrepareLC( R_DMUL_EXIT_CONF );
conf->SetPromptL( *prompt );
TInt resp = conf->RunLD();
CleanupStack::PopAndDestroy( prompt ); // prompt
downloadCnt = iRegistryModel.DownloadCount();
if ( resp == EAknSoftkeyYes || resp == EAknSoftkeyOk )
{
for ( TInt i = downloadCnt - 1; i >=0; --i )
{
RHttpDownload* dl = downloads.At(i); //current download
dl->GetBoolAttribute( EDlAttrPausable , isPausable );
if (!( isPausable ) ) // delete only Non pausable Downloads
{
// Delete not attached downloads.
dl->Delete(); // Return value ignored.
}
}
okToExit = ETrue;
}
else
{
if ( iRegistryModel.DownloadsListInstalled() )
{
// Make visible
iRegistryModel.DownloadsList().DisplayDownloadsListL();
}
}
}
CLOG_LEAVEFN("CDownloadMgrUiUserInteractions::OkToExitL");
return okToExit;
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::PrepareToExit
// -----------------------------------------------------------------------------
//
EXPORT_C
TInt CDownloadMgrUiUserInteractions::PrepareToExit( CEikAppUi& aAppUi,
TClientAppExitType aExitType,
TVwsViewId aViewId,
TUid aCustomMessageId,
const TDesC8& aViewActivationMsg )
{
CLOG_ENTERFN("CDownloadMgrUiUserInteractions::PrepareToExit");
// send a message to all running PD applications and tell that browser is exiting
TRAP_IGNORE( iUiUtils->SendMsgTerminateToPdAppsL( iProgressiveDownloadLaunched ));
TRAPD( err, PrepareToExitL( &aAppUi, aExitType, aViewId, aCustomMessageId,
aViewActivationMsg ) );
CLOG_WRITE_FORMAT(" err: %d",err);
CLOG_LEAVEFN("CDownloadMgrUiUserInteractions::PrepareToExit");
return err;
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::PrepareToExit
// -----------------------------------------------------------------------------
//
EXPORT_C
TInt CDownloadMgrUiUserInteractions::PrepareToExit( TUint32 aAppUid,
TUint32 aViewId,
TUint32 aCustomMessageId )
{
CLOG_ENTERFN("CDownloadMgrUiUserInteractions::PrepareToExit 2");
// send a message to all running PD applications and tell that browser is exiting
TRAP_IGNORE( iUiUtils->SendMsgTerminateToPdAppsL( iProgressiveDownloadLaunched ));
// Convert parameters to the necessary form
TVwsViewId viewId( TUid::Uid(aAppUid), TUid::Uid(aViewId) );
TUid customMessageId( TUid::Uid(aCustomMessageId) );
TRAPD( err, PrepareToExitL( 0, ETerminatedBySystem, viewId, customMessageId,
KNullDesC8 ) );
CLOG_WRITE_FORMAT(" err: %d",err);
CLOG_LEAVEFN("CDownloadMgrUiUserInteractions::PrepareToExit 2");
return err;
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::HandleDownloadL
// -----------------------------------------------------------------------------
//
EXPORT_C
void CDownloadMgrUiUserInteractions::HandleDownloadL( RHttpDownload& aDownload )
{
CLOG_ENTERFN("CDownloadMgrUiUserInteractions::HandleDownloadL");
CLOG_WRITE_FORMAT("aDownload: 0x%x",&aDownload);
// Handle only completed downloads.
// check if it is COD download. They do not require any handling - just delete them.
if ( CodDownloadL( aDownload ) )
{
// Nothing to do with COD - just delete it.
User::LeaveIfError( aDownload.Delete() );
CLOG_WRITE(" Delete OK");
}
else
{
// Handling depends on EDlAttrAction
TInt32 action(0);
User::LeaveIfError( aDownload.GetIntAttribute
( EDlAttrAction, action ) );
CLOG_WRITE_FORMAT(" EDlAttrAction: %d",action);
if ( action == EDoNothing )
{
// Do nothing
}
else if ( action & EMove )
{
// Move content to the location pointed by EDlAttrDestFilename.
User::LeaveIfError( aDownload.Move() );
}
else if ( action & EPdLaunch )
{
// again do nothing since it's already launched during the process
}
else
{
// Defaulting to Launch
HBufC8* ctype = iUiUtils->ContentTypeL( aDownload, ETrue );
CleanupStack::PushL( ctype );
TBool isLaunchType( KSisxApplication().Find( *ctype ) != KErrNotFound || KWidgetMimeType().Find (*ctype) != KErrNotFound );
if(!isLaunchType)
{
isLaunchType = KPipApplication().Find( *ctype ) != KErrNotFound ;
}
if(!isLaunchType)
{
isLaunchType = KSharingConfig().Find( *ctype ) != KErrNotFound ;
}
if( isLaunchType )
{
// launch content
iUiUtils->HandleContentL( aDownload, *iExtension );
}
else if ( iUiUtils->DrmDownloadL( aDownload ) )
{
if( iUiUtils->IsCorruptedDcfL( aDownload ) )
{
aDownload.Delete();
// Show 'File corrupted' info note.
iUiUtils->InfoNoteL( R_DMUL_OK_NOTE, R_DMUL_ERROR_CORRUPTED );
}
else
{
TBool isBadMimeInDcf = iUiUtils->IsBadMimeInDcfL( aDownload );
TBool isSupported = EFalse;
if ( isBadMimeInDcf )
{
isSupported = EFalse;
}
else
{
isSupported = iUiUtils->IsContentTypeSupportedL( aDownload );
}
TBool previewRights;
if ( iUiUtils->DrmRightsOnThePhoneL( aDownload, previewRights ) )
{
// get content type of media file in drm content
isLaunchType = KDrmInnerContentTypesToLaunch().Find( *ctype ) != KErrNotFound;
if( isLaunchType )
{
// launch content
iUiUtils->HandleContentL( aDownload, *iExtension );
}
else if ( previewRights )
{
// Normal behaviour
HandleNormalDownloadL( aDownload );
}
else
{
HandleCompletionWithQueryL( aDownload, IsUiBusy(), isSupported, ETrue, ETrue );
}
}
else
{
// No rights on the phone
HandleCompletionWithQueryL( aDownload, IsUiBusy(), isSupported, ETrue, EFalse );
}
}
}
else // Normal download
{
HandleNormalDownloadL( aDownload );
}
CleanupStack::PopAndDestroy( ctype );
}
}
CLOG_LEAVEFN("CDownloadMgrUiUserInteractions::HandleDownloadL");
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::GetIntAttributeL
// -----------------------------------------------------------------------------
//
EXPORT_C
void CDownloadMgrUiUserInteractions::GetIntAttributeL( const TUint /*aAttribute*/, TInt32& /*aValue*/ )
{
User::Leave( KErrNotSupported );
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::GetBoolAttributeL
// -----------------------------------------------------------------------------
//
EXPORT_C
void CDownloadMgrUiUserInteractions::GetBoolAttributeL( const TUint aAttribute, TBool& aValue )
{
if ( aAttribute == EAttrSuppressDownloadConfirmation )
{
aValue = iExtension->iSuppressDownloadConfirmation;
}
else
{
User::Leave( KErrNotSupported );
}
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::GetStringAttributeL
// -----------------------------------------------------------------------------
//
EXPORT_C
void CDownloadMgrUiUserInteractions::GetStringAttributeL( const TUint /*aAttribute*/, TDes16& /*aValue*/ )
{
User::Leave( KErrNotSupported );
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::GetStringAttributeL
// -----------------------------------------------------------------------------
//
EXPORT_C
void CDownloadMgrUiUserInteractions::GetStringAttributeL( const TUint /*aAttribute*/, TDes8& /*aValue*/ )
{
User::Leave( KErrNotSupported );
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::SetIntAttributeL
// -----------------------------------------------------------------------------
//
EXPORT_C
void CDownloadMgrUiUserInteractions::SetIntAttributeL( const TUint /*aAttribute*/, TInt32 /*aValue*/ )
{
User::Leave( KErrNotSupported );
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::SetBoolAttributeL
// -----------------------------------------------------------------------------
//
EXPORT_C
void CDownloadMgrUiUserInteractions::SetBoolAttributeL( const TUint aAttribute, TBool aValue )
{
if ( aAttribute == EAttrSuppressDownloadConfirmation )
{
iExtension->iSuppressDownloadConfirmation = aValue;
}
else
{
User::Leave( KErrNotSupported );
}
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::SetStringAttributeL
// -----------------------------------------------------------------------------
//
EXPORT_C
void CDownloadMgrUiUserInteractions::SetStringAttributeL( const TUint /*aAttribute*/, const TDesC16& /*aValue*/ )
{
User::Leave( KErrNotSupported );
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::SetStringAttributeL
// -----------------------------------------------------------------------------
//
EXPORT_C
void CDownloadMgrUiUserInteractions::SetStringAttributeL( const TUint /*aAttribute*/, const TDesC8& /*aValue*/ )
{
User::Leave( KErrNotSupported );
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::HandleCompletionWithQueryL
// -----------------------------------------------------------------------------
//
void CDownloadMgrUiUserInteractions::HandleCompletionWithQueryL
( RHttpDownload& aDownload,
TBool aIsUiBusy,
TBool aIsSupported,
TBool aIsDrm,
TBool aDrmRightsOnPhone )
{
if( !iDlgActive )
{
iDlgActive = ETrue;
TRAPD( err, DoHandleCompletionWithQueryL( aDownload, aIsUiBusy,
aIsSupported, aIsDrm, aDrmRightsOnPhone ));
iDlgActive = EFalse;
User::LeaveIfError( err );
}
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::DoHandleCompletionWithQueryL
// -----------------------------------------------------------------------------
//
void CDownloadMgrUiUserInteractions::DoHandleCompletionWithQueryL
( RHttpDownload& aDownload, TBool CLOG_ONLY( aIsUiBusy ),
TBool aIsSupported,
TBool aIsDrm,
TBool aDrmRightsOnPhone )
{
CLOG_ENTERFN("CDownloadMgrUiUserInteractions::HandleCompletionWithQueryL");
CLOG_WRITE_FORMAT(" aIsUiBusy: %d",aIsUiBusy);
CLOG_WRITE_FORMAT(" aIsSupported: %d",aIsSupported);
CLOG_WRITE_FORMAT(" aIsDrm: %d",aIsDrm);
CLOG_WRITE_FORMAT(" aDrmRightsOnPhone: %d",aDrmRightsOnPhone);
// File name :
User::LeaveIfError( aDownload.GetStringAttribute
( EDlAttrName, iExtension->iFileName ) );
HBufC* queryText = StringLoader::LoadLC
( R_DMUL_COMPLETED_CONF, iExtension->iFileName );
CAknQueryDialog* dlg = CAknQueryDialog::NewL();
// Set up the initial dialog. Some parameters are changed then.
dlg->PrepareLC( R_DMUL_COMPL_DOWNLOAD_CONF );
CLOG_WRITE(" PrepareLC OK");
dlg->SetPromptL( *queryText );
// Set up softkeys:
TInt cbaResourceId(0);
TInt okSkMeans(0);
if ( aIsDrm && aIsSupported )
{
if ( !aDrmRightsOnPhone )
{
// aIsUiBusy must be EFalse!
cbaResourceId = R_DMUL_SOFTKEYS_COMPL_DRM_SAVE;
okSkMeans = EAknSoftkeySave;
}
else
{
cbaResourceId = R_DMUL_SOFTKEYS_COMPL_DRM;
okSkMeans = EAknSoftkeyShow;
}
}
else
{
// aIsUiBusy must be EFalse!
if ( aIsSupported )
{
cbaResourceId = R_DMUL_SOFTKEYS_COMPL_DL;
okSkMeans = EAknSoftkeyShow;
}
else
{
cbaResourceId = R_DMUL_SOFTKEYS_UNSUPP_COMPL_DL;
okSkMeans = EAknSoftkeySave;
}
}
dlg->ButtonGroupContainer().SetCommandSetL( cbaResourceId );
// Execute it.
TInt skId = dlg->RunLD();
CLOG_WRITE_FORMAT(" RunLD %d",skId);
dlg = NULL;
CleanupStack::PopAndDestroy( /*queryText*/ ); // queryText
// Translate OK key to the proper meaning
if ( skId == EAknSoftkeyOk )
{
skId = okSkMeans;
}
if ( skId == EAknSoftkeyShow )
{
// First clode the downloads list.
if ( iRegistryModel.DownloadsListInstalled() )
{
iRegistryModel.DownloadsList().CancelDisplayingDownloadsList();
}
iUiUtils->HandleContentL( aDownload, *iExtension );
// After the termination of the handler, download is removed
// from the list of downloads in NotifyHandlerExit().
}
else if ( skId == EAknSoftkeySave )
{
iUiUtils->SaveContentL( aDownload );
// The save (moving) procedure is asynchronous!
// When ends, HandleDMgrEventL() is called.
}
else
{
// Do nothing.
}
CLOG_LEAVEFN("CDownloadMgrUiUserInteractions::HandleCompletionWithQueryL");
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::PrepareToExitL
// Behaviour depends on:
// - EDlMgrExitAction is EExitDelete or not
// - some download is non-pausable - these will always be deleted by DM engine
// - hidden downloads
// - no media downloads are taken into account!
// -----------------------------------------------------------------------------
//
void CDownloadMgrUiUserInteractions::PrepareToExitL( CEikAppUi* /*aAppUi*/,
TClientAppExitType aExitType,
TVwsViewId aViewId,
TUid aCustomMessageId,
const TDesC8& aViewActivationMsg )
{
CLOG_ENTERFN("CDownloadMgrUiUserInteractions::PrepareToExitL");
__ASSERT_ALWAYS( aExitType==ETerminatedBySystem, Panic( EUiLibPanCalledWhenUserExit ) );
TInt32 exitAction( EExitNothing );
User::LeaveIfError( iRegistryModel.DownloadMgr().
GetIntAttribute( EDlMgrExitAction, exitAction ) );
CLOG_WRITE_FORMAT(" exitAction: %d",exitAction);
if ( exitAction == EExitDelete )
{
// No need to initialize soft notifications - downloads will be deleted
CLOG_LEAVEFN("CDownloadMgrUiUserInteractions::PrepareToExitL");
return;
}
// count non-pausable and hidden downloads
TInt downloadCnt = iRegistryModel.DownloadCount();
TInt ignoredDownloads = 0;
TBool isPausable(0);
TBool isHidden(0);
TBool isNoMedia(0);
TInt err(0);
THttpDownloadState state;
const CDownloadArray& downloads = iRegistryModel.DownloadMgr().CurrentDownloads();
for( TInt i = 0; i < downloadCnt; ++i )
{
RHttpDownload* dl = downloads.At(i); // current download
// we do not have to show the download in case of invalid descriptor
HBufC* name = HBufC::NewLC( KMaxUrlLength );
TPtr tempPtr = name->Des();
dl->GetStringAttribute( EDlAttrName, tempPtr );
err = dl->GetBoolAttribute( EDlAttrPausable, isPausable );
if ( !err )
{
err = dl->GetBoolAttribute( EDlAttrHidden, isHidden );
}
if( !err )
{
err = dl->GetIntAttribute(EDlAttrState, (TInt32&)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(!err && state == EHttpDlCompleted )
{
state = EHttpDlMultipleMOCompleted;
}
else if(!err && state == EHttpDlFailed )
{
state = EHttpDlMultipleMOFailed;
}
}
if ( !err )
{
err = dl->GetBoolAttribute( EDlAttrNoMedia, isNoMedia );
}
CLOG_WRITE_FORMAT(" err: %d",err);
if ( !err && ( !isPausable || isHidden ||isNoMedia || state == EHttpDlMultipleMOCompleted || !tempPtr.Length() ) )
{
++ignoredDownloads;
}
CleanupStack::PopAndDestroy( name ); // name
}
CLOG_WRITE_FORMAT(" downloadCnt: %d",downloadCnt);
CLOG_WRITE_FORMAT(" ignoredDownloads: %d",ignoredDownloads);
// the new downloadCnt holds only those downloads, that count from the
// point of soft notifications
downloadCnt = downloadCnt - ignoredDownloads;
// Is the App server app?
TBool startedAsServerApp = ((CEikonEnv&)iCoeEnv).StartedAsServerApp();
CLOG_WRITE_FORMAT(" startedAsServerApp: %d",startedAsServerApp);
if ( startedAsServerApp )
{
if ( downloadCnt > 0 )
{
// Display GSN-Emb.
iUiUtils->InitializeSoftNotifEmbL
( aViewId, aCustomMessageId, aViewActivationMsg );
// And check if there is a running stand-alone instance from the
// same application. If there is no such, then initialize GSN-Stnd.
if ( IsStandAloneAppRunning() )
{
// The stand-alone app will show GSN, if necessary when terminated.
}
else
{
// It has to initialize GSN-Stnd
iUiUtils->InitializeSoftNotifStndL
( aViewId, aCustomMessageId, aViewActivationMsg );
}
}
else
{
// No downloads left in - don't show GSN.
}
}
else // Stand-alone
{
if ( downloadCnt > 0 )
{
// Display GSN-Stnd.
iUiUtils->InitializeSoftNotifStndL
( aViewId, aCustomMessageId, aViewActivationMsg );
}
else
{
// No downloads left in - don't show GSN.
}
}
CLOG_LEAVEFN("CDownloadMgrUiUserInteractions::PrepareToExitL");
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::IsStandAloneAppRunning
// -----------------------------------------------------------------------------
//
TBool CDownloadMgrUiUserInteractions::IsStandAloneAppRunning()
{
CLOG_ENTERFN("CDownloadMgrUiUserInteractions::IsStandAloneAppRunning");
TBool ret(0);
if ( !((CEikonEnv&)iCoeEnv).StartedAsServerApp() )
{
// This is the stand-alone app.
ret = ETrue;
}
else
{
TApaTaskList apaTaskList( iCoeEnv.WsSession() );
TUid appUid = iRegistryModel.ClientAppUid();
TApaTask apaTask = apaTaskList.FindApp( appUid );
ret = apaTask.Exists();
}
CLOG_LEAVEFN("CDownloadMgrUiUserInteractions::IsStandAloneAppRunning");
return ret;
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::DeleteEventHandlerShowingDlConfirmation
// -----------------------------------------------------------------------------
//
void CDownloadMgrUiUserInteractions::DeleteEventHandlerShowingDlConfirmation
( RHttpDownload& aDownload )
{
CLOG_ENTERFN("CDownloadMgrUiUserInteractions::DeleteEventHandlerShowingDlConfirmation");
// Find the event handler of this download
TInt handlerCount = iEventHandlerArray->Count();
for( TInt i = 0; i < handlerCount; ++i )
{
CUserInteractionsEventHandler* handlerI =
(CUserInteractionsEventHandler*)iEventHandlerArray->At(i);
if ( &(handlerI->Download()) == &aDownload )
{
// found one.
if ( handlerI->DownloadConfirmationShown() )
{
iEventHandlerArray->Remove( handlerI );
delete handlerI;
--i;
--handlerCount;
}
}
}
CLOG_LEAVEFN("CDownloadMgrUiUserInteractions::DeleteEventHandlerShowingDlConfirmation");
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::DeleteEventHandlers
// -----------------------------------------------------------------------------
//
void CDownloadMgrUiUserInteractions::DeleteEventHandlers( RHttpDownload& aDownload )
{
CLOG_ENTERFN("CDownloadMgrUiUserInteractions::DeleteEventHandlers");
// Find the event handler of this download
TInt handlerCount = iEventHandlerArray->Count();
for( TInt i = 0; i < handlerCount; ++i )
{
CUserInteractionsEventHandler* handlerI =
(CUserInteractionsEventHandler*)iEventHandlerArray->At(i);
if ( &(handlerI->Download()) == &aDownload )
{
// found one.
delete handlerI;
iEventHandlerArray->Remove( handlerI );
--i;
--handlerCount;
}
}
CLOG_LEAVEFN("CDownloadMgrUiUserInteractions::DeleteEventHandlers");
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::DownloadConfirmationsShown
// -----------------------------------------------------------------------------
//
TInt CDownloadMgrUiUserInteractions::DownloadConfirmationsShown() const
{
TInt count( 0 );
TInt totalCount = iEventHandlerArray->Count();
CUserInteractionsEventHandler* eventHandler = NULL;
for ( TInt i = 0; i < totalCount; ++i )
{
eventHandler = (CUserInteractionsEventHandler*)(*iEventHandlerArray)[i];
if ( eventHandler->DownloadConfirmationShown() )
{
count++;
}
}
return count;
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::IsUiBusy
// UI is busy, if:
// - DocHandler exists in CUserInteractionsUtils.
// - CodHandler ServiceFlow is running.
// -----------------------------------------------------------------------------
//
TBool CDownloadMgrUiUserInteractions::IsUiBusy() const
{
TBool isUiBusy( ETrue ); // True by default.
if ( iUiUtils->IsUiBusy() )
{
isUiBusy = ETrue;
}
else if ( IsCodServiceFlowRunning() )
{
isUiBusy = ETrue;
}
else
{
isUiBusy = EFalse;
}
return isUiBusy;
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::PostponeCodHandlingL
// -----------------------------------------------------------------------------
//
void CDownloadMgrUiUserInteractions::PostponeCodHandlingL( RHttpDownload& aDownload )
{
iExtension->PostponeCodHandlingL( aDownload );
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::IsPostponed
// -----------------------------------------------------------------------------
//
TBool CDownloadMgrUiUserInteractions::IsPostponed( RHttpDownload& aDownload ) const
{
return iExtension->IsPostponed( aDownload );
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::SchedulePostponedDownloadL
// -----------------------------------------------------------------------------
//
void CDownloadMgrUiUserInteractions::SchedulePostponedDownloadL()
{
iExtension->SchedulePostponedDownloadL();
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::IsCodServiceFlowRunning
// -----------------------------------------------------------------------------
//
TBool CDownloadMgrUiUserInteractions::IsCodServiceFlowRunning() const
{
TBool isCodServiceFlowRunning( ETrue ); // true by default
TRAP_IGNORE( isCodServiceFlowRunning = IsCodServiceFlowRunningL() );
return isCodServiceFlowRunning;
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::IsCodServiceFlowRunning
// -----------------------------------------------------------------------------
//
TBool CDownloadMgrUiUserInteractions::IsCodServiceFlowRunning
( RHttpDownload& aDownload ) const
{
TBool isCodServiceFlowRunning( ETrue ); // true by default
TRAP_IGNORE( isCodServiceFlowRunning = IsCodServiceFlowRunningL( aDownload ) );
return isCodServiceFlowRunning;
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::IsCodServiceFlowRunningL
// -----------------------------------------------------------------------------
//
TBool CDownloadMgrUiUserInteractions::IsCodServiceFlowRunningL() const
{
CLOG_ENTERFN("CDownloadMgrUiUserInteractions::IsCodServiceFlowRunningL");
TBool isCodServiceFlowRunning( EFalse ); // false by default!
// Walk through the list of downloads.
RHttpDownloadMgr& dMgr = iRegistryModel.DownloadMgr();
TInt downloads = dMgr.CurrentDownloads().Count();
for ( TInt i = 0; i < downloads; ++i )
{
RHttpDownload* download =
(RHttpDownload*)(dMgr.CurrentDownloads().At(i));
CLOG_WRITE_FORMAT(" download: %x",download);
if ( IsCodServiceFlowRunningL( *download ) )
{
CLOG_WRITE(" Found!");
isCodServiceFlowRunning = ETrue;
break;
}
}
CLOG_LEAVEFN("CDownloadMgrUiUserInteractions::IsCodServiceFlowRunningL");
return isCodServiceFlowRunning;
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::IsCodServiceFlowRunningL
// CodHandler ServiceFlow is running, if a COD download is hidden, but it is
// not in the so called postponed downloads list.
// -----------------------------------------------------------------------------
//
TBool CDownloadMgrUiUserInteractions::IsCodServiceFlowRunningL
( RHttpDownload& aDownload ) const
{
CLOG_ENTERFN("CDownloadMgrUiUserInteractions::IsCodServiceFlowRunningL DL");
TBool isCodServiceFlowRunning( EFalse ); // false by default!
// COD download?
TBool isCodDownload( EFalse );
User::LeaveIfError( aDownload.GetBoolAttribute
( EDlAttrCodDownload, isCodDownload ) );
CLOG_WRITE_FORMAT(" isCodDownload: %d",isCodDownload);
if ( isCodDownload )
{
// check if hidden?
TBool isHidden( EFalse );
User::LeaveIfError( aDownload.GetBoolAttribute
( EDlAttrHidden, isHidden ) );
CLOG_WRITE_FORMAT(" isHidden: %d",isHidden);
if ( isHidden )
{
// if it is not in postponed downloads list...
if ( !IsPostponed( aDownload ) )
{
isCodServiceFlowRunning = ETrue;
}
}
}
CLOG_LEAVEFN("CDownloadMgrUiUserInteractions::IsCodServiceFlowRunningL DL");
return isCodServiceFlowRunning;
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::HandleNormalDownloadL
// -----------------------------------------------------------------------------
//
void CDownloadMgrUiUserInteractions::HandleNormalDownloadL( RHttpDownload& aDownload )
{
CLOG_ENTERFN("CDownloadMgrUiUserInteractions::HandleNormalDownloadL");
if ( IsUiBusy() )
{
// It's handling a downloaded content. Do not open a new.
CLOG_WRITE(" IsUiBusy() true");
}
else
{
iRegistryModel.DownloadsList().DisplayDownloadsListL(aDownload);
}
CLOG_LEAVEFN("CDownloadMgrUiUserInteractions::HandleNormalDownloadL");
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::CodDownloadL
// -----------------------------------------------------------------------------
//
TBool CDownloadMgrUiUserInteractions::CodDownloadL( RHttpDownload& aDownload ) const
{
CLOG_ENTERFN("CDownloadMgrUiUserInteractions::CodDownloadL");
TBool isCodDownload( EFalse );
User::LeaveIfError( aDownload.GetBoolAttribute
( EDlAttrCodDownload, isCodDownload ) );
CLOG_WRITE_FORMAT(" ret: %d",isCodDownload);
CLOG_LEAVEFN("CDownloadMgrUiUserInteractions::CodDownloadL");
return isCodDownload;
}
// -----------------------------------------------------------------------------
// CDownloadMgrUiUserInteractions::HandleDMgrEventL
// -----------------------------------------------------------------------------
//
void CDownloadMgrUiUserInteractions::HandleDMgrEventL
( RHttpDownload& aDownload, THttpDownloadEvent aEvent )
{
CLOG_WRITE_EVENT("UsrInt",&aDownload,aEvent);
if ( aEvent.iDownloadState == EHttpDlMediaInserted ||
aEvent.iDownloadState == EHttpDlPausable ||
aEvent.iDownloadState == EHttpDlNonPausable )
{
// This event is not handled by User Interactions Event Handler
}
else if ( aEvent.iDownloadState == EHttpDlDeleted ||
aEvent.iDownloadState == EHttpDlDeleting )
{
DeleteEventHandlers( aDownload );
iUiUtils->DownloadHasBeenDeleted( &aDownload );
}
else if ( aEvent.iDownloadState == EHttpDlAlreadyRunning )
{
// Display information note
CUserInteractionsUtils::InfoNoteL( R_DMUL_OK_NOTE, R_DMUL_NOTE_DOWNLOADING );
}
else if ( aEvent.iDownloadState == EHttpDlInprogress )
{
if ( aEvent.iProgressState == EHttpProgResponseHeaderReceived ||
aEvent.iProgressState == EHttpContTypeRecognitionAvail ||
aEvent.iProgressState == EHttpProgSupportedMultiPart ||
aEvent.iProgressState == EHttpProgDlNameChanged )
{
// Create the asynchronous event handler that will handle the event.
CUserInteractionsEventHandler* asyncHandler =
new (ELeave) CUserInteractionsEventHandler
( aDownload, aEvent, iRegistryModel, *iEventHandlerArray, *iUiUtils );
CleanupStack::PushL( asyncHandler );
// iEventHandlerArray will own it
iEventHandlerArray->AppendL( asyncHandler );
CleanupStack::Pop( asyncHandler ); // asyncHandler - ownership transferred
}
// If COD is downloaded, close download confirmation query for this download:
// COD shows accept/reject query too.
else if ( aEvent.iProgressState == EHttpProgCodDescriptorDownloaded )
{
// delete event handlers showing download confirmation.
DeleteEventHandlerShowingDlConfirmation( aDownload );
}
else if ( aEvent.iProgressState == EHttpProgCodDescriptorAccepted ||
aEvent.iProgressState == EHttpProgCodLoadEnd ||
aEvent.iProgressState == EHttpProgCodPdAvailable )
{
// Open downloads list.
// Create the asynchronous event handler that will handle the event, because
// it will run a 'wait' dialog.
CUserInteractionsEventHandler* asyncHandler =
new (ELeave) CUserInteractionsEventHandler
( aDownload, aEvent, iRegistryModel, *iEventHandlerArray, *iUiUtils );
CleanupStack::PushL( asyncHandler );
// iEventHandlerArray will own it
iEventHandlerArray->AppendL( asyncHandler );
CleanupStack::Pop( asyncHandler ); // asyncHandler - ownership transferred
}
}
else if ( aEvent.iDownloadState == EHttpDlPaused )
{
if ( aEvent.iProgressState == EHttpContentTypeReceived )
{
// Create the asynchronous event handler that will handle the event.
CUserInteractionsEventHandler* asyncHandler =
new (ELeave) CUserInteractionsEventHandler
( aDownload, aEvent, iRegistryModel, *iEventHandlerArray, *iUiUtils );
CleanupStack::PushL( asyncHandler );
// iEventHandlerArray will own it
iEventHandlerArray->AppendL( asyncHandler );
CleanupStack::Pop( asyncHandler ); // asyncHandler - ownership transferred
}
}
else
{
// In case of completed or failed download, delete event handlers
// that are showing download confirmation.
if ( aEvent.iDownloadState == EHttpDlMultipleMOCompleted ||
aEvent.iDownloadState == EHttpDlMultipleMOFailed )
{
DeleteEventHandlerShowingDlConfirmation( aDownload );
}
// Create the asynchronous event handler that will handle the event.
CUserInteractionsEventHandler* asyncHandler =
new (ELeave) CUserInteractionsEventHandler
( aDownload, aEvent, iRegistryModel, *iEventHandlerArray, *iUiUtils );
CleanupStack::PushL( asyncHandler );
// iEventHandlerArray will own it
iEventHandlerArray->AppendL( asyncHandler );
CleanupStack::Pop( asyncHandler ); // asyncHandler - ownership transferred
}
}
/* End of file. */