/*
* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "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: Application UI class required by AVKON application architecture.
*
*/
// INCLUDE FILES
#include <AknGlobalNote.h>
#include <avkon.hrh>
#include <apgwgnam.h>
#include <hlplch.h>
#include <e32base.h>
#include <e32property.h>
#include <eikproc.h>
#include <apacln.h>
#include <coeutils.h>
#include <StringLoader.h>
#include <textresolver.h>
#include <aknnotewrappers.h>
#include <AknTaskList.h>
#include <aknview.h>
#include <featmgr.h>
#include <centralrepository.h>
#include <settingsinternalcrkeys.h>
#include <ctsydomainpskeys.h>
#include <caf/caferr.h>
#include <eikapp.h>
#include <pathinfo.h>
#include <sysutil.h>
#include <apgcli.h>
#include <AknDlgShut.h>
#include <aknconsts.h>
#include <activeidle2domainpskeys.h>
#ifdef RD_RA_SUPPORT_FOR_MUSIC_PLAYER
#include <AiwGenericParam.h>
#endif
#include <mpxplaybackutility.h>
#include <mpxcollectionutility.h>
#include <mpxplaybackmessage.h>
#include <mpxviewutility.h>
#include <mpxmusicplayerviewplugin.hrh>
#include <mpx.rsg>
#include <mpxcollectionmessage.h>
#include <mpxcollectionplaylist.h>
#include <mpxcollectionpath.h>
#include <mpxcollectionplugin.hrh>
#include <mpxmedia.h>
#include <mpxmediageneraldefs.h>
#include <mpxmediadrmdefs.h>
#include <mpxcollectionuihelper.h>
#include <mpxcollectionhelperfactory.h>
#include <mpxmediaarray.h>
#include <mpxmediacontainerdefs.h>
#include <mpxmediakeyhandler.h>
#include <mpxharvesterutility.h>
#include <mpxdrmmediautility.h>
#include <mpxcollectionmessagedefs.h>
#include <mpxmessagegeneraldefs.h>
#include <mpxcollectionplugin.hrh>
#include <mpxcommandgeneraldefs.h>
#include <mpxcollectioncommanddefs.h>
// Cover UI start
//#ifdef __COVER_DISPLAY
#include <aknSDData.h>
#include <AknMediatorFacade.h>
#include <MediatorCommandInitiator.h>
#include <MediatorDomainUIDs.h>
#include "mplayersecondarydisplayapi.h"
#include <featmgr.h>
//#endif
// Cover UI end
#ifdef __CAMESE_SUPERDISTRIBUTION_SUPPORT
#include "camesedrmhandler.h"
#endif
#ifdef RD_RA_SUPPORT_FOR_MUSIC_PLAYER
#include <DocumentHandler.h>
#include <apmstd.h>
#endif //RD_RA_SUPPORT_FOR_MUSIC_PLAYER
#include "mpxinternalcrkeys.h"
#include "mpxcommandhandler.h"
#ifdef RD_BROWSER_PROGRESSIVE_DOWNLOAD
#include <AiwGenericParam.h>
#include "mpxPDcommandhandler.h"
#endif // RD_BROWSER_PROGRESSIVE_DOWNLOAD
#include "mpxcommonuihelper.h"
#include <mpxcommonui.rsg> //for R_MPX_FILE_NOT_FOUND_TEXT
#include "mpxappui.h"
#include "mpxcontroller.h"
#include "mpxrestorepath.h"
#include "mpxdocument.h"
#include "mpxtlshelper.h"
#include "mpxlog.h"
#include "mpxappui.hrh"
#include <mpxconstants.h>
#include <mpxviewpluginmanager.h>
#include <mpxviewplugin.h>
#include <iaupdate.h>
#include <iaupdateparameters.h>
#include <iaupdateresult.h>
// CONSTANTS
_LIT( KMPXLineChange, "\n" );
_LIT(KMPXMusicplayerPrivateFolder, "\\private\\");
_LIT(KMPXMusicPlayerExec, "mpx.exe" );
const TInt KMPXMusicPlayerAlreadySaved( -5000 );
// Application Uid for Active Idle app
#ifdef __ACTIVE_IDLE
const TUid KMPXUidIdleApp = { 0x101FD64C };
#else
const TUid KMPXUidIdleApp = KPSUidActiveIdle2; // use this one instead because the "aisystemuids.hrh" is not export
#endif
// MusicPlayer SIS Package UID
#define KMPXMusicPlayerSISPkgUid 0x101FFC62
_LIT8( KMmMessage, "mm://musicsuite?action=exit" );
const TInt KMmUid3( 0x101f4cd2 );
// Granularity for ring tone mime types array
const TInt KMPXRingToneMimeTypesGranularity( 10 );
const TInt KMPXMinVolume( 0 );
const TInt KMPXMaxVolume(100);
#ifdef RD_RA_SUPPORT_FOR_MUSIC_PLAYER
_LIT8(KDataTypeRAM,"audio/x-pn-realaudio-plugin");
#endif //RD_RA_SUPPORT_FOR_MUSIC_PLAYER
const TInt KMaxIntLen( 10 );
_LIT8( KMVPrefix, "MVviewID:" );
const TInt KMVPrefixLen( 9 );
const TUid KLocalPlaybackUid = { 0x101FFC06 };
const TUid KPhoneAppUid = {0x100058B3};
const TInt KWaitNoteImpUid = 0x101FFC6C; // refresh wait note UID
const TInt KLowestMemoryNeeded = 5242880; //5 Mbytes
const TUid KCRUidMPXMPSettings = {0x101FFCDC};
const TUint32 KMPXMPPlaybackRandomMode = 0x0B;
const TUint32 KMPXMPPlaybackRepeatMode = 0x0C;
// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
// C++ default constructor.
// ---------------------------------------------------------------------------
//
CMPXAppUi::CMPXAppUi()
: iRingToneMimeTypes( KMPXRingToneMimeTypesGranularity ),
iCurrentIndex( KErrNotFound ), iSaveMode( EMPXSaveModeIdle ),
iStandAlone(EFalse),
iMaxVolume(KMPXMaxVolume)
#ifdef RD_BROWSER_PROGRESSIVE_DOWNLOAD
,iAppStartedByBrowser(EFalse)
,iPdPbvStartedByBrowser(EFalse)
,icollectionBrowsed(EFalse)
#endif // RD_BROWSER_PROGRESSIVE_DOWNLOAD
#ifdef FF_OOM_MONITOR2_COMPONENT //__ENABLE_MPX_BUSYSETTING_FOR_OOM2
,iOomPriority( ROomMonitorSession::EOomPriorityNormal )
#endif //FF_OOM_MONITOR2_COMPONENT
{
}
// ---------------------------------------------------------------------------
// Symbian 2nd phase constructor can leave.
// ---------------------------------------------------------------------------
//
void CMPXAppUi::ConstructL()
{
MPX_FUNC( "CMPXAppUi::ConstructL" );
#ifndef __ENABLE_MSK
BaseConstructL( EAknEnableSkin
#ifdef SINGLE_CLICK_INCLUDED
| EAknSingleClickCompatible
#endif
);
#else
BaseConstructL( EAknEnableSkin | EAknEnableMSK
#ifdef SINGLE_CLICK_INCLUDED
| EAknSingleClickCompatible
#endif
);
#endif // __ENABLE_MSK
iCommonUiHelper = CMPXCommonUiHelper::NewL();
// Cover UI start
//#ifdef __COVER_DISPLAY
// initialize FeatureManager
FeatureManager::InitializeLibL();
if ( FeatureManager::FeatureSupported( KFeatureIdCoverDisplay ) )
{
iCoverDisplay = ETrue;
iCommandInitiator = CMediatorCommandInitiator::NewL( NULL );
}
else
{
iCoverDisplay = EFalse;
}
//#endif // __COVER_DISPLAY
// Cover UI end
if ( MPXUser::IsCallOngoing( EPSCTsyCallTypeH324Multimedia ) )
{
HBufC* text =
StringLoader::LoadLC( R_MPX_VIDEO_CALL_ONGOING );
CAknGlobalNote* globalInfoNote = CAknGlobalNote::NewLC();
// Cover UI start
//#ifdef __COVER_DISPLAY
if ( iCoverDisplay )
{
CAknSDData* sddata = CAknSDData::NewL(
KMPlayerNoteCategory,
EMPlayerNoteVideoCall,
KNullDesC8);
globalInfoNote->SetSecondaryDisplayData(sddata); // ownership transferred
}
//#endif //__COVER_DISPLAY
// Cover UI end
globalInfoNote->ShowNoteL(
EAknGlobalInformationNote,
text->Des() );
CleanupStack::PopAndDestroy( globalInfoNote );
CleanupStack::PopAndDestroy( text );
Exit();
return;
}
//check memory
#ifdef FF_OOM_MONITOR2_COMPONENT
CheckAvailableMemoryByOomL( KLowestMemoryNeeded );
#else
CheckAvailableMemory( KLowestMemoryNeeded );
#endif //FF_OOM_MONITOR2_COMPONENT
if ( !IsEmbedded() )
{
// Do we support podcasting in music player?
// Event if repository get fails, it will default to EFalse
//
TInt val(0);
CRepository* repository = CRepository::NewL( KCRUidMPXMPFeatures );
repository->Get( KMPXMPLocalVariation, val );
iDisablePodcasting = val&KMPXDisablePodcastingOption ? ETrue : EFalse;
iStartInAlbumMenu = val&KMPXStartMusicPlayerinArtistsandAlbums ? ETrue : EFalse;
delete repository;
CreateMemberVariablesL();
TUid defaultView( iViewUtility->DefaultViewUid() );
// Pre-load views in standalone mode
iViewUtility->PreLoadViewsL( TUid::Uid( KMusicPlayerAppUidConstant ) );
#ifndef __ENABLE_PODCAST_IN_MUSIC_MENU
iCollectionUtility->Collection().OpenL(
TUid::Uid(EMPXCollectionPluginMusic));
#endif
if ( iStartInAlbumMenu )
{
// We want to open the music player to the albums level for 9.2
// Changes in other areas will also be needed.
CMPXCollectionPath* path = iCollectionUiHelper->MusicMenuPathL();
CleanupStack::PushL( path );
path->AppendL(3); // Albums
MPX_DEBUG_PATH(*path);
iCollectionUtility->Collection().OpenL( *path );
CleanupStack::PopAndDestroy( path );
}
else
{
CMPXCollectionPath* path = iCollectionUtility->Collection().PathL();
CleanupStack::PushL( path );
MPX_DEBUG1("CMPXAppUi::ConstructL() current collection path");
#ifdef __ENABLE_PODCAST_IN_MUSIC_MENU
MPX_DEBUG1("CMPXAppUi::ConstructL() restoring stale path");
CMPXCollectionPath* mainMusicMenu = CMPXCollectionPath::NewL();
CleanupStack::PushL( mainMusicMenu );
mainMusicMenu->AppendL(0x101FFC3A);
iCollectionUtility->Collection().OpenL( *mainMusicMenu );
CleanupStack::PopAndDestroy( mainMusicMenu );
CleanupStack::PopAndDestroy( path );
#else
MPX_DEBUG1( "CMPXAppUi::ConstructL wrong path" );
if( path->Levels() > 1 )
{
// Correct the path by opening 0 levels
MPX_DEBUG1("CMPXAppUi::ConstructL() restoring stale path");
CMPXCollectionPath* root = CMPXCollectionPath::NewL();
CleanupStack::PushL( root );
iCollectionUtility->Collection().OpenL( *root );
CleanupStack::PopAndDestroy( root );
}
CleanupStack::PopAndDestroy( path );
#endif
}
if ( defaultView != KNullUid )
{
iViewUtility->SetAsDefaultViewL( defaultView );
}
else
{
iViewUtility->SetAsDefaultViewL(
TUid::Uid( KMPXPluginTypeMainUid ) );
}
#ifdef __ENABLE_PODCAST_IN_MUSIC_MENU
// Startup database checker
iController = CMPXController::NewL(iDisablePodcasting);
#endif // __ENABLE_PODCAST_IN_MUSIC_MENU
// Only in stand alone mode
iHarvesterUtility = CMPXHarvesterFactory::NewL();
iHarvesterUtility->CheckForSystemEventsL();
#ifdef _DEBUG
TBool iExitOptionHidden = EFalse;
#else // _DEBUG
TBool iExitOptionHidden = iCommonUiHelper->ExitOptionHiddenL();
#endif // _DEBUG
if(iExitOptionHidden)
{
// Do not offer choice to exit application from task swapper.
CEikonEnv::Static()->SetSystem( ETrue );
}
RProcess proc;
CleanupClosePushL( proc );
CMPXCommonUiHelper::SetStandAloneModePId( proc.Id().Id() );
CleanupStack::PopAndDestroy( &proc );
}
iRingToneMimeTypes.AppendL(_L("application/vnd.nokia.ringing-tone"));
iRingToneMimeTypes.AppendL(_L("audio/x-midi"));
iRingToneMimeTypes.AppendL(_L("audio/midi"));
iRingToneMimeTypes.AppendL(_L("audio/sp-midi"));
iRingToneMimeTypes.AppendL(_L("audio/amr"));
iRingToneMimeTypes.AppendL(_L("audio/amr-wb"));
iRingToneMimeTypes.AppendL(_L("audio/awb"));
iRingToneMimeTypes.AppendL(_L("audio/x-amr"));
iRingToneMimeTypes.AppendL(_L("audio/audio/vnd.nokia.mobile-xmf"));
iLaunchModePlaying = EFalse;
}
// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CMPXAppUi::~CMPXAppUi()
{
MPX_DEBUG1( "-->CMPXAppUi::~CMPXAppUi()" );
#ifdef FF_OOM_MONITOR2_COMPONENT
SetMpxOomPriorityL( ROomMonitorSession::EOomPriorityNormal );
#endif //FF_OOM_MONITOR2_COMPONENT
if ( !IsEmbedded() )
{
CMPXCommonUiHelper::SetStandAloneModePId( 0 );
}
// Cover UI Start
// #ifdef __COVER_DISPLAY
FeatureManager::UnInitializeLib();
delete iCommandInitiator;
// #endif // __COVER_DISPLAY
// Cover UI End
delete iPathRestore;
delete iController;
delete iProcessParameter;
#ifdef RD_BROWSER_PROGRESSIVE_DOWNLOAD
delete iPdParameterHandler;
#endif // RD_BROWSER_PROGRESSIVE_DOWNLOAD
delete iIdle;
if ( iCollectionUtility )
{
iCollectionUtility->Close();
}
if ( iPlaybackUtility )
{
TRAP_IGNORE( iPlaybackUtility->CommandL( EPbCmdClose ) );
TRAP_IGNORE( iPlaybackUtility->RemoveObserverL( *this ) );
iPlaybackUtility->Close();
}
if ( iViewUtility )
{
iViewUtility->RemoveObserver( this );
iViewUtility->Close();
}
delete iCommonUiHelper;
if( iCollectionUiHelper )
{
iCollectionUiHelper->Close();
}
if ( iCollectionHelper )
{
iCollectionHelper->Close();
}
if( iHarvesterUtility )
{
iHarvesterUtility->Close();
}
delete iMediaKeyHandler;
delete iSettingsRepository;
iFile.Close();
iDeferredViewActivationUid.Close();
delete iSavePath;
iRingToneMimeTypes.Reset();
delete iSaveHelper;
#ifdef __CAMESE_SUPERDISTRIBUTION_SUPPORT
delete iCameseDrmHandler;
#endif
#ifdef RD_RA_SUPPORT_FOR_MUSIC_PLAYER
delete iDocHandler;
#endif //RD_RA_SUPPORT_FOR_MUSIC_PLAYER
CleanUpdateParams();
MPX_DEBUG1( "<--CMPXAppUi::~CMPXAppUi()" );
}
// ---------------------------------------------------------------------------
// Querying whether the application is launched in embedded mode or not.
// ---------------------------------------------------------------------------
//
TBool CMPXAppUi::IsEmbedded() const
{
return iEikonEnv->StartedAsServerApp();
}
// ---------------------------------------------------------------------------
// Opens temporary playlist or album from buffer.
// ---------------------------------------------------------------------------
//
void CMPXAppUi::OpenPlaylistFromBufferL(
const TDesC& aBuffer,
TDesC& aName )
{
MPX_FUNC( "CMPXAppUi::OpenPlaylistFromBufferL" );
TPtrC bufPtr( aBuffer );
TInt offset = 0;
CMPXMediaArray* tracksArray = CMPXMediaArray::NewL();
CleanupStack::PushL( tracksArray );
while ( bufPtr.Length() > 0 )
{
offset = bufPtr.Find( KMPXLineChange );
CMPXMedia* track = CMPXMedia::NewL();
CleanupStack::PushL( track );
track->SetTObjectValueL( KMPXMediaGeneralType, EMPXItem);
track->SetTObjectValueL( KMPXMediaGeneralCategory, EMPXSong );
if ( offset == KErrNotFound )
{
TParsePtrC fn( bufPtr );
track->SetTextValueL( KMPXMediaGeneralTitle, fn.Name() );
track->SetTextValueL( KMPXMediaGeneralUri, bufPtr );
// Set bufPtr to the end of buffer
bufPtr.Set( bufPtr.Right( 0 ) ); //magic
}
else
{
TParsePtrC fn( bufPtr.Left( offset ) );
track->SetTextValueL( KMPXMediaGeneralTitle, fn.Name() );
track->SetTextValueL( KMPXMediaGeneralUri, fn.FullName() );
// Move past the line feed
bufPtr.Set( bufPtr.Mid( ++offset ) );
}
tracksArray->AppendL( track );
CleanupStack::Pop( track );
}
CMPXMedia* media = CMPXMedia::NewL();
CleanupStack::PushL( media );
media->SetTObjectValueL( KMPXMediaGeneralType, EMPXItem);
media->SetTObjectValueL( KMPXMediaGeneralCategory, EMPXPlaylist );
if ( aName.Length() > 0 )
{
media->SetTObjectValueL( KMPXMediaGeneralTitle, aName );
}
media->SetCObjectValueL( KMPXMediaArrayContents, tracksArray );
media->SetTObjectValueL( KMPXMediaArrayCount, tracksArray->Count() );
iCollectionUiHelper->OpenL( MPXTlsHelper::HostUid(), *media,
this, EMPXCollectionPluginMusic );
CleanupStack::PopAndDestroy( media );
CleanupStack::PopAndDestroy( tracksArray );
}
#ifdef RD_RA_SUPPORT_FOR_MUSIC_PLAYER
// -----------------------------------------------------------------------------
// CMPXAppUi::ForwardAiwParametersToMediaPlayer
// -----------------------------------------------------------------------------
//
CAiwGenericParamList* CMPXAppUi::CreateForwardAiwParametersLC(
const CAiwGenericParamList* aParamList) const
{
MPX_FUNC( "CMPXAppUi::ForwardAiwParametersToMediaPlayerL" );
//Read parameters that were appended to the parameter list
//Creates a new parameter list which will be forwarded to Media Player
CAiwGenericParamList* newParamList = CAiwGenericParamList::NewLC();
if (aParamList)
{
TInt index = 0;
//param contains the specific parameter being looked for in the parameter list
//if found, append it again so it can be passed to Media Player
//Move parameter
const TAiwGenericParam* param = aParamList->FindFirst(index,
EGenericParamAllowMove);
if (param)
{
TBool allowMove(ETrue);
TAiwVariant allowMoveVariant(allowMove);
TAiwGenericParam genericParamAllowMove(EGenericParamAllowMove,
allowMoveVariant);
newParamList->AppendL(genericParamAllowMove);
}
index = 0;
param = NULL;
//Save parameter
param = aParamList->FindFirst(index, EGenericParamAllowSave);
if (param)
{
TBool allowSave(ETrue);
TAiwVariant allowSaveVariant(allowSave);
TAiwGenericParam genericParamAllowSave(EGenericParamAllowSave,
allowSaveVariant);
newParamList->AppendL(genericParamAllowSave);
}
index = 0;
param = NULL;
//Resolution parameter
param = aParamList->FindFirst(index, EGenericParamResolution);
if (param)
{
//For future use
}
index = 0;
param = NULL;
//File parameter
param = aParamList->FindFirst(index, EGenericParamFile);
if (param)
{
TDataType dataType( _L8("audio/x-pn-realaudio") );
TAiwVariant filename( _L8("c:\\system\\temp\\RtspTemp.ram") );
TAiwGenericParam param( EGenericParamFile, filename );
newParamList->AppendL( param );
}
index = 0;
param = NULL;
//Access Point parameter
param = aParamList->FindFirst(index, EGenericParamAccessPoint);
if (param)
{
TInt32 value = 0;
TInt32 ret = param->Value().Get(value);
if (ret)
{
TAiwVariant accessPointVariant(value);
TAiwGenericParam genericParamAccessPoint(EGenericParamAccessPoint,
accessPointVariant);
newParamList->AppendL(genericParamAccessPoint);
}
}
}
return newParamList;
}
#endif
// ---------------------------------------------------------------------------
// Opens the specified file in response to a corresponding message.
// ---------------------------------------------------------------------------
//
void CMPXAppUi::OpenFileL(
CFileStore*& /* aFileStore */,
RFile& aFile,
const CAiwGenericParamList* aParams )
{
MPX_FUNC( "CMPXAppUi::OpenFileL" );
// Duplicate the file handle passed in before
// creating the member variables.
TFileName filename;
aFile.FullName( filename );
iFile.Close();
iFile.Duplicate( aFile );
aFile.Close();
if ( IsEmbedded() )
{
CreateMemberVariablesL();
iViewUtility->PreLoadViewL( TUid::Uid( KMPXPluginTypeEmbeddedPlaybackUid ));
}
#ifdef RD_RA_SUPPORT_FOR_MUSIC_PLAYER
// Get MIME type
RApaLsSession apa;
User::LeaveIfError( apa.Connect() );
CleanupClosePushL( apa );
TDataRecognitionResult result;
User::LeaveIfError( apa.RecognizeData( iFile, result ));
CleanupStack::PopAndDestroy( &apa );
TDataType dataType = TDataType( KDataTypeRAM() );
if ( result.iDataType == dataType )
{
CAiwGenericParamList* paramList = CreateForwardAiwParametersLC(aParams);
iDocHandler->OpenFileEmbeddedL(iFile, dataType, *paramList);
CleanupStack::PopAndDestroy(paramList);
iDocHandler->SetExitObserver(this);
}
else
#endif //RD_RA_SUPPORT_FOR_MUSIC_PLAYER
{
// Open File with Collection Helper
iCollectionUiHelper->OpenL( MPXTlsHelper::HostUid(), filename,
this, EMPXCollectionPluginMusic );
}
}
// ---------------------------------------------------------------------------
// CMPXAppUi::ActivatePhoneAppL
// ---------------------------------------------------------------------------
//
void CMPXAppUi::ActivatePhoneAppL()
{
MPX_FUNC( "CMPXAppUi::ActivatePhoneAppL" );
TApaTaskList apaTaskList( CCoeEnv::Static()->WsSession() );
TApaTask apaTask = apaTaskList.FindApp( KPhoneAppUid );
if ( apaTask.Exists() )
{
// Bring phone to foreground
apaTask.BringToForeground();
}
// Move Music Player to background
// magic: -1 = force wg to background
}
// ----------------------------------------------------------------------------
// void CMPXAppUi::DeferredExitCallback
// call back function for deferred exit.
// ----------------------------------------------------------------------------
//
TInt CMPXAppUi::DeferredExitCallback( TAny* aPtr )
{
MPX_FUNC( "CMPXAppUi::DeferredExitCallback" );
CMPXAppUi* self = static_cast<CMPXAppUi*>( aPtr );
TRAP_IGNORE( self->HandleCommandL( EEikCmdExit ) );
return KErrNone;
}
// ---------------------------------------------------------------------------
// Start a waitnote dialog
// ---------------------------------------------------------------------------
//
void CMPXAppUi::StartWaitNoteL( TWaitNoteType aNoteType )
{
CloseWaitNoteL();
TUid waitnoteId = TUid::Uid( KMPXPluginTypeWaitNoteDialogUid );
TPckg<TWaitNoteType> note = aNoteType;
HBufC* arg = MPXUser::AllocL( note );
CleanupStack::PushL( arg );
iViewUtility->ActivateViewL( waitnoteId, arg );
CleanupStack::PopAndDestroy( arg );
}
// ---------------------------------------------------------------------------
// Close the waitnote dialog
// ---------------------------------------------------------------------------
//
void CMPXAppUi::CloseWaitNoteL()
{
TUid waitnoteId = TUid::Uid( KMPXPluginTypeWaitNoteDialogUid );
TUid activeView = iViewUtility->ActiveViewType();
if( activeView == waitnoteId )
{
CMPXViewPlugin* pi =
iViewUtility->ViewPluginManager().PluginL( TUid::Uid(KWaitNoteImpUid) );
pi->DeactivateView();
}
}
// ---------------------------------------------------------------------------
// From MMPXMediaKeyHandlerObserver.
// Handle media key commands.
// ---------------------------------------------------------------------------
//
void CMPXAppUi::HandleMediaKeyCommand(
const TMPXPlaybackCommand aCommand,
const TInt aData )
{
MPX_FUNC( "CMPXAppUi::HandleMediaKeyCommand" );
switch ( aCommand )
{
case EPbCmdSetVolume:
{
TMPXPlaybackState playerState( EPbStateNotInitialised );
playerState = iPlaybackUtility->StateL();
if ( !MPXUser::IsCallOngoing( KMPXCallTypeGenericVoice ) ||
( playerState == EPbStatePlaying ) ||
( playerState == EPbStateSeekingForward ) ||
( playerState == EPbStateSeekingBackward ) ||
iPdParameterHandler )
{
TMPXPlaybackState pdPlayerState( EPbStateNotInitialised );
if ( iPdParameterHandler )
{
pdPlayerState = iPdParameterHandler->PdStateL();
}
// only process command if there no call ongoing
// or if we're actively playing during call
if ( IsForeground() || EPbStatePlaying == playerState || EPbStatePlaying == pdPlayerState )
{
if ( aData != iCurrentVolume )
{
SetVolume( aData );
}
// popup volume control even if volume didn't change
HandlePopupL( EPbCmdSetVolume );
}
}
break;
}
case EPbCmdMuteVolume:
{
TMPXPlaybackState playerState( EPbStateNotInitialised );
playerState = iPlaybackUtility->StateL();
if ( !MPXUser::IsCallOngoing( KMPXCallTypeGenericVoice ) ||
( playerState == EPbStatePlaying ) ||
( playerState == EPbStateSeekingForward ) ||
( playerState == EPbStateSeekingBackward ) )
{
// only process command if there no call ongoing
// or if we're actively playing during call
if ( IsForeground() || EPbStatePlaying == playerState )
{
MuteVolume();
HandlePopupL( EPbCmdMuteVolume );
}
}
break;
}
case EPbCmdUnMuteVolume:
{
TMPXPlaybackState playerState( EPbStateNotInitialised );
playerState = iPlaybackUtility->StateL();
if ( !MPXUser::IsCallOngoing( KMPXCallTypeGenericVoice ) ||
( playerState == EPbStatePlaying ) ||
( playerState == EPbStateSeekingForward ) ||
( playerState == EPbStateSeekingBackward ) )
{
// only process command if there no call ongoing
// or if we're actively playing during call
if ( IsForeground() || EPbStatePlaying == playerState )
{
UnMuteVolume();
HandlePopupL( EPbCmdUnMuteVolume );
}
}
break;
}
default:
{
// Dispatches all other commands
TBool foregroundApp( IsForeground() );
if ( !IsDisplayingMenuOrDialog() && foregroundApp )
{
// Forward the command to view to handle when
// music is foreground app and not displaying
// dialogs or the options menu
if ( iView )
{
MPX_DEBUG2( "CMPXAppUi::HandleMediaKeyCommand sending command %d to view", MPXCmdForPbCmd(aCommand) );
iView->HandleCommandL( MPXCmdForPbCmd(aCommand) );
}
}
else
{
TMPXPlaybackState playerState( EPbStateNotInitialised );
playerState = iPlaybackUtility->StateL();
if ( foregroundApp && IsDisplayingDialog() )
{
// displaying dialog in the foreground
if ( EPbStatePlaying == playerState ||
EPbStatePaused == playerState ||
EPbStateSeekingForward == playerState ||
EPbStateSeekingBackward == playerState ||
aCommand == EPbCmdPlay ||
aCommand == EPbCmdPlayPause )
{
// In playing/paused state, all media keys are active.
// Now playing view is not bring to foreground.
// Seeking forward/backwards is also "playing"
MPX_DEBUG2( "CMPXAppUi::HandleMediaKeyCommand Dialog displaying, sending command %d to DoHandleMediaKeyCommandL", aCommand );
DoHandleMediaKeyCommandL( aCommand );
}
else
{
MPX_DEBUG2( "CMPXAppUi::HandleMediaKeyCommand Dialog displaying, inactive state, command %d ignored", aCommand );
}
}
else
{
// displaying menu/not foreground, pass to view to handle only play command
if ( EPbStatePlaying == playerState ||
EPbStatePaused == playerState ||
EPbStateSeekingForward == playerState ||
EPbStateSeekingBackward == playerState )
{
MPX_DEBUG2( "CMPXAppUi::HandleMediaKeyCommand Menu displaying/not foreground, sending command %d to DoHandleMediaKeyCommandL", aCommand );
DoHandleMediaKeyCommandL( aCommand );
}
else if ( ( aCommand == EPbCmdPlay || aCommand == EPbCmdPlayPause ) && iView )
{
if ( !foregroundApp )
{
MPX_DEBUG2( "CMPXAppUi::HandleMediaKeyCommand Menu displaying/not foreground, active idle foreground, sending command %d to DoHandleMediaKeyCommandL", aCommand );
// not foreground, play without loading playback view
DoHandleMediaKeyCommandL( aCommand );
}
else
{
MPX_DEBUG2( "CMPXAppUi::HandleMediaKeyCommand Menu displaying/not foreground, sending command %d to view", aCommand );
iView->HandleCommandL( MPXCmdForPbCmd(aCommand) );
}
}
else if ( aCommand == EPbCmdPlay || aCommand == EPbCmdPlayPause )
{
// play command without a view, this case
// happens when music player is started in starter
// and has not been activated yet
// if music player gets this event, that means embedded mode
// is not active. safe to just use TApaTask to switch task
// bring music player to foreground in this case
TApaTaskList tasList( CEikonEnv::Static()->WsSession() );
TApaTask task =
tasList.FindApp( KAppUidMusicPlayerX );
if ( task.Exists() )
{
task.BringToForeground();
}
}
else
{
MPX_DEBUG2( "CMPXAppUi::HandleMediaKeyCommand Menu displaying/not foreground, inactive state, command %d ignored", aCommand );
}
}
}
break;
}
}
}
// ---------------------------------------------------------------------------
// Additional handling of media key commands.
// Determine if the command will be passed to the playback engine.
// ---------------------------------------------------------------------------
//
void CMPXAppUi::DoHandleMediaKeyCommandL(
TMPXPlaybackCommand aCommand )
{
MPX_FUNC( "CMPXAppUi::DoHandleMediaKeyCommandL" );
TBool handleCommand(EFalse);
TMPXPlaybackState playerState( iPlaybackUtility->StateL() );
MMPXSource* source( iPlaybackUtility->Source() );
switch ( aCommand )
{
case EPbCmdPlay:
case EPbCmdPause:
case EPbCmdPlayPause:
{
#ifdef RD_BROWSER_PROGRESSIVE_DOWNLOAD
if ( source || iPdParameterHandler )
#else
if ( source )
#endif
{
handleCommand = ETrue;
}
break;
}
case EPbCmdStop:
{
handleCommand = ETrue;
break;
}
case EPbCmdNext:
{
// TODO: Invalid if in progressive download mode??
// ignore next key in stopped mode, except when
// the foreground is playbackview
if (( EPbStateStopped != playerState ||
KMPXPluginTypePlaybackUid == iCurrentViewType.iUid ||
KMPXPluginTypeEmbeddedPlaybackUid == iCurrentViewType.iUid ) &&
source )
{
handleCommand = ETrue;
}
break;
}
case EPbCmdPrevious:
{
// TODO: Invalid if in progressive download mode??
// ignore previous key in stopped mode, except when
// the foreground is playbackview
if (( EPbStateStopped != playerState ||
KMPXPluginTypePlaybackUid == iCurrentViewType.iUid ||
KMPXPluginTypeEmbeddedPlaybackUid == iCurrentViewType.iUid) &&
source )
{
handleCommand = ETrue;
}
break;
}
case EPbCmdStartSeekForward:
{
// TODO: Invalid if in progressive download mode??
if (( EPbStatePlaying == playerState ||
EPbStatePaused == playerState ||
EPbStateSeekingBackward == playerState ) &&
source )
{
handleCommand = ETrue;
}
break;
}
case EPbCmdStartSeekBackward:
{
// TODO: Invalid if in progressive download mode??
if (( EPbStatePlaying == playerState ||
EPbStatePaused == playerState ||
EPbStateSeekingForward == playerState ) &&
source )
{
handleCommand = ETrue;
}
break;
}
case EPbCmdStopSeeking:
{
if (( EPbStateSeekingForward == playerState ||
EPbStateSeekingBackward == playerState ) &&
source )
{
handleCommand = ETrue;
}
break;
}
default:
{
// Do nothing
break;
}
}
if ( handleCommand )
{
#ifdef RD_BROWSER_PROGRESSIVE_DOWNLOAD
if (iPdParameterHandler)
{
iPdParameterHandler->HandleCommandL( aCommand );
}
else
{
iPlaybackUtility->CommandL( aCommand );
}
#else
iPlaybackUtility->CommandL( aCommand );
#endif
// Control popup behaviour
HandlePopupL( aCommand );
}
}
// -----------------------------------------------------------------------------
// Control popup behaviour.
// -----------------------------------------------------------------------------
//
void CMPXAppUi::HandlePopupL(
TMPXPlaybackCommand aCommand )
{
MPX_FUNC( "CMPXAppUi::HandlePopupL" );
TBool showPlaybackPopup( ETrue );
TBool showVolumePopup( ETrue );
if ( IsForeground() )
{
switch ( iCurrentViewType.iUid )
{
case KMPXPluginTypePlaybackUid:
case KMPXPluginTypeEmbeddedPlaybackUid:
case KMPXPluginTypeMainUid:
{
// do not show playback popup in these views
MPX_DEBUG2( "CMPXAppUi::HandlePopupL active view type is 0x%x, not showing popup", iCurrentViewType.iUid );
showPlaybackPopup = EFalse;
break;
}
default:
{
MPX_DEBUG2( "CMPXAppUi::HandlePopupL active view type is 0x%x, showing popup", iCurrentViewType.iUid );
break;
}
}
}
else if ( !IsForeground() && IsActiveIdleEnabled() && IsIdleAppForeground() )
{
showPlaybackPopup = EFalse;
}
if ( !IsForeground())
{
if ( IsActiveIdleEnabled() && IsIdleAppForeground() )
{
showVolumePopup = ETrue;
}
else
{
showVolumePopup = EFalse;
}
}
switch ( aCommand )
{
case EPbCmdStop:
{
iMediaKeyHandler->DismissNotifier( EDisplayMediaPopup );
break;
}
case EPbCmdPrevious:
case EPbCmdNext:
{
if ( showPlaybackPopup )
{
// skip backwards should start timer right away
// because it'll not receive events to trigger the timer
// if skipping multiple songs, the timer will be reset
// everytime it reaches a song
// skip fowards should also start timer right away
// becuase if it's the last song, there won't be any events
// to trigger the timer
iMediaKeyHandler->ShowPlaybackPopupL( EMPXPopupTimeout );
}
break;
}
case EPbCmdPlay:
case EPbCmdPause:
case EPbCmdPlayPause:
case EPbCmdStartSeekForward:
case EPbCmdStartSeekBackward:
{
if ( showPlaybackPopup )
{
iMediaKeyHandler->ShowPlaybackPopupL( EMPXPopupNoTimeout );
}
break;
}
case EPbCmdStopSeeking:
{
if ( showPlaybackPopup )
{
iMediaKeyHandler->ShowPlaybackPopupL( EMPXPopupTimeout );
}
break;
}
case EPbCmdSetVolume:
case EPbCmdMuteVolume:
case EPbCmdUnMuteVolume:
{
if ( showVolumePopup && iMediaKeyHandler)
{
// display pop up volume control
iMediaKeyHandler->ShowVolumePopupL();
}
break;
}
default:
{
// Do nothing
break;
}
}
}
// -----------------------------------------------------------------------------
// Check if Active Idle app is on foreground
// -----------------------------------------------------------------------------
//
TBool CMPXAppUi::IsIdleAppForeground()
{
MPX_FUNC( "CMPXAppUi::IsIdleAppForeground" );
TBool isIdleActive( EFalse );
// Gets the window group id of the app in foreground
RWsSession& wsSession = CCoeEnv::Static()->WsSession();
TInt windowGroupId = wsSession.GetFocusWindowGroup();
if ( windowGroupId >= 0 )
{
TRAP_IGNORE(
{
CApaWindowGroupName* wgName = CApaWindowGroupName::NewL(
wsSession, windowGroupId );
isIdleActive = ( wgName->AppUid() == KMPXUidIdleApp );
delete wgName;
} );
}
return isIdleActive;
}
// -----------------------------------------------------------------------------
// Check if Active Idle is enabled
// -----------------------------------------------------------------------------
//
TBool CMPXAppUi::IsActiveIdleEnabled()
{
MPX_FUNC( "CMPXAppUi::IsActiveIdleEnabled" );
TBool res( EFalse );
#ifdef __ACTIVE_IDLE
if (! FeatureManager::FeatureSupported( KFeatureIdActiveIdle ) )
return EFalse;
#endif
if ( !iSettingsRepository )
{
TRAP_IGNORE(
{
iSettingsRepository = CRepository::NewL(
KCRUidPersonalizationSettings );
} );
}
if ( iSettingsRepository )
{
TInt value( 0 );
TInt err( iSettingsRepository->Get( KSettingsActiveIdleState, value ) );
if ( !err && value )
{
res = ETrue;
}
}
return res;
}
// ---------------------------------------------------------------------------
// Creates and initializes all member variables
// ---------------------------------------------------------------------------
//
void CMPXAppUi::CreateMemberVariablesL()
{
MPX_FUNC("CMPXAppUi::CreateMemberVariablesL()");
TUid playbackMode( KAppUidMusicPlayerX );
TUid collectionMode( KAppUidMusicPlayerX );
if ( IsEmbedded() )
{
playbackMode = KPbModeNewPlayer;
collectionMode = MPXTlsHelper::HostUid(); // Collection context == host UID
}
if ( !iCollectionUtility )
{
iCollectionUtility = MMPXCollectionUtility::NewL( this, collectionMode );
}
// Get an instance of view utility
if ( !iViewUtility )
{
iViewUtility = MMPXViewUtility::UtilityL();
iViewUtility->AddObserverL( this );
iViewUtility->ConstructDefaultViewHistoryL();
}
if ( !iCollectionUiHelper )
{
iCollectionUiHelper = CMPXCollectionHelperFactory:: NewCollectionUiHelperL();
}
// Create a new playback utility instance
if ( !iPlaybackUtility )
{
iPlaybackUtility = MMPXPlaybackUtility::UtilityL( playbackMode );
iPlaybackUtility->AddObserverL( *this );
// get the current Volume and Max Volume
iPlaybackUtility->PropertyL(*this, EPbPropertyVolume);
iPlaybackUtility->PropertyL(*this, EPbPropertyMaxVolume);
if( !IsEmbedded() )
{
TInt randomMode = 0;
TInt repeatMode = 0;
CRepository* repository = CRepository::NewL( KCRUidMPXMPSettings );
repository->Get( KMPXMPPlaybackRandomMode, randomMode );
repository->Get( KMPXMPPlaybackRepeatMode, repeatMode );
delete repository;
repository = NULL;
MPX_DEBUG3("CMPXAppUi::CreateMemberVariablesL() randomMode(%d), repeatMode(%d)", randomMode, repeatMode);
iPlaybackUtility->SetL( EPbPropertyRandomMode, randomMode );
iPlaybackUtility->SetL( EPbPropertyRepeatMode, repeatMode );
}
}
if ( !iMediaKeyHandler )
{
// Handle media key in appui
iMediaKeyHandler = MMPXMediaKeyHandler::NewL(
EDisplayVolumePopup | EDisplayMediaPopup,
this );
}
if( !IsEmbedded() )
{
iPathRestore = CMPXRestorePath::NewL( iPlaybackUtility,
iCollectionUiHelper );
// Fetch the music collection UID
RArray<TUid> uid;
CleanupClosePushL( uid );
uid.AppendL( TUid::Uid(EMPXCollectionPluginMusic) );
iMusicCollectionId = iCollectionUtility->CollectionIDL( uid.Array() );
// Fetch the podcast collection UID
if( !iDisablePodcasting )
{
uid.Reset();
uid.AppendL( TUid::Uid(EMPXCollectionPluginPodCast) );
iPodcastCollectionId = iCollectionUtility->CollectionIDL( uid.Array() );;
}
CleanupStack::PopAndDestroy( &uid );
}
#ifdef __CAMESE_SUPERDISTRIBUTION_SUPPORT
// In case Camese Superdistribution is enabled,
// we just need to initialize the Camese Drm Handler
// object. It will act as a collection utility
// observer and will handle WMDRM protected content
// in lieu of the AppUi.
if ( !iCameseDrmHandler )
{
iCameseDrmHandler = CCameseDrmHandler::NewL(iFile);
}
#endif
#ifdef RD_RA_SUPPORT_FOR_MUSIC_PLAYER
if( !iDocHandler )
{
iDocHandler = CDocumentHandler::NewL(iEikonEnv->Process());
}
#endif //RD_RA_SUPPORT_FOR_MUSIC_PLAYER
}
// ---------------------------------------------------------------------------
// Save file
// ---------------------------------------------------------------------------
//
void CMPXAppUi::DoSaveL()
{
MPX_DEBUG1("CMPXAppUi::DoSaveL(): entering");
ASSERT( iFile.SubSessionHandle() );
// Get target path
TFileName newFile;
CreateAutomaticSavePathL( newFile );
delete iSavePath;
iSavePath = NULL;
iSavePath = newFile.AllocL();
// display waiting note
TParsePtrC fileParse( newFile );
HBufC* string( StringLoader::LoadLC( R_MPX_SAVE_ONE_ITEM_WAIT_NOTE,
fileParse.Name() ));
// Cover UI start
//#ifdef __COVER_DISPLAY
if ( iCommandInitiator )
{
HBufC8* filename8 = HBufC8::NewLC( KMaxFileName );
filename8->Des().Copy( fileParse.Name() );
TPtrC name(KNullDesC);
name.Set( fileParse.Name() );
HBufC8* data = HBufC8::NewLC(KMaxFileName);
TPtr8 dataPtr = data->Des();
RDesWriteStream str(dataPtr);
TPtrC8 b(KNullDesC8);
b.Set(*filename8);
str << b;
str.CommitL();
iCommandInitiator->IssueCommand( KMediatorSecondaryDisplayDomain,
KMPlayerNoteCategory,
EMPlayerNoteSaveOneItem,
TVersion (0,0,0),
*data );
CleanupStack::PopAndDestroy(2);
}
//#endif // __COVER_DISPLAY
// Cover UI end
iCommonUiHelper->ShowWaitNoteL(
*string,
R_AVKON_SOFTKEYS_EMPTY,
EFalse,
this );
CleanupStack::PopAndDestroy( string );
TMPXLaunchMode mode( MPXTlsHelper::LaunchMode() );
iPausedForSave = EFalse;
if ( EMPXLaunchModeTrack == mode )
{
// Close the file in playback engine
iPlaybackUtility->CommandL( EPbCmdPreservePosition );
iPlaybackUtility->CommandL( EPbCmdPreserveState );
iPlaybackUtility->CommandL( EPbCmdClose );
}
else
{
if ( EPbStatePlaying == iPlaybackUtility->StateL() )
{
iPlaybackUtility->CommandL( EPbCmdPause );
iPausedForSave = ETrue;
}
}
// Check disk space
TBool allowMove( MPXTlsHelper::AllowMove() );
#ifdef RD_MULTIPLE_DRIVE
// Only need to check if on phone memory. All other drives were
// checked while creating the automatic save path
if( fileParse.Drive().CompareF( PathInfo::PhoneMemoryRootPath().Left(2) ) == 0 )
#else
// Do not need to check if on memory card as that was already done
if( fileParse.Drive().CompareF( PathInfo::MemoryCardRootPath().Left(2) ) != 0 )
#endif // RD_MULTIPLE_DRIVE
{
// If a file is being moved then there is no need to check for
// available space, as moving the file doesn't increase space consumption
// Check is still needed if a file is being copied
RFs& fs( iEikonEnv->FsSession() );
TInt size( 0 );
iFile.Size( size );
if ( !allowMove )
{
if ( SysUtil::FFSSpaceBelowCriticalLevelL( &fs, size ) )
{
iCommonUiHelper->DismissWaitNoteL();
User::Leave( KErrDiskFull ); // Phone memory full, Avkon shows note
}
}
}
// Create save helper if not created
if ( !iSaveHelper )
{
iSaveHelper = CMPXSaveHelper::NewL( this, this );
}
// s60 change. playlist could be opened from messaging app.
// in the case we don't want to copy in async mode
if (( EMPXLaunchModeTrack != MPXTlsHelper::LaunchMode() )
&& (!iCommonUiHelper->IsHostMessagingL()))
{
iSaveHelper->StartCopyOperationL( iFile, newFile, allowMove );
iFile.Close();
}
else
{
if ( iCommonUiHelper->IsHostMessagingL() )
{
// save ringtone. We need to do sync call to save file because
// the asyc calls doesn't guarantee the file is copied completely.
// This is deal with a situation when set ringtone from messaging app
// that the ringtone files are kept in proviate directory.
iSaveHelper->StartCopyOperationL( iFile, newFile, EFalse, ETrue );
}
else
{
iSaveHelper->StartCopyOperationL( iFile, newFile, allowMove );
iFile.Close();
}
}
MPX_DEBUG1("CMPXAppUi::DoSaveL(): exiting");
}
// -----------------------------------------------------------------------------
// CreateAutomaticSavePathL
// -----------------------------------------------------------------------------
//
void CMPXAppUi::CreateAutomaticSavePathL( TFileName& aNewPath )
{
MPX_DEBUG1("CMPXAppUi::CreateAutomaticSavePathL(): entering");
RFs& fs( iEikonEnv->FsSession() );
TFileName fileName;
iFile.FullName( fileName );
TParsePtrC fileParse( fileName );
// Get the size and check if there's enough room to store
TInt size( 0 );
User::LeaveIfError( iFile.Size( size ));
#ifdef RD_MULTIPLE_DRIVE
// Get the next available drive (internal mass store, MMC or phone memory)
HBufC* defaultRootPath( iCommonUiHelper->AvailableDriveLC( size ) );
aNewPath = *defaultRootPath;
CleanupStack::PopAndDestroy( defaultRootPath );
#else
HBufC* defaultRootPath( iCommonUiHelper->DefaultDriveLC() );
aNewPath = *defaultRootPath;
CleanupStack::PopAndDestroy( defaultRootPath );
if ( aNewPath.CompareF( PathInfo::MemoryCardRootPath()) == 0 )
{
// only if memory card is supported, check if there is enough space
// on the card.
TBool isBelowCritical( EFalse );
TRAPD( err, isBelowCritical =
SysUtil::MMCSpaceBelowCriticalLevelL( &fs, size ));
if ( err || isBelowCritical )
{
aNewPath = PathInfo::PhoneMemoryRootPath();
}
}
#endif // RD_MULTIPLE_DRIVE
TInt pathResId( KErrNotFound );
// Get MIME type to see if it's a ringtone
RApaLsSession apa;
User::LeaveIfError( apa.Connect() );
CleanupClosePushL( apa );
TDataRecognitionResult result;
User::LeaveIfError( apa.RecognizeData( iFile, result ));
CleanupStack::PopAndDestroy( &apa );
TPtrC resultPtr( result.iDataType.Des() );
TInt val( 0 );
if ( iRingToneMimeTypes.Find( resultPtr, val ) == 0 )
{
pathResId = R_MPX_TARGETFOLDER_RINGTONES;
}
else if ( iCommonUiHelper->IsHostMessagingL() )
{
pathResId = R_MPX_TARGETFOLDER_ATTACHMENT;
}
else
{
pathResId = R_MPX_TARGETFOLDER_DOWNLOADS;
}
HBufC* defaultPath( StringLoader::LoadLC( pathResId ));
aNewPath += *defaultPath;
aNewPath += fileParse.NameAndExt();
CleanupStack::PopAndDestroy( defaultPath );
if ( !ConeUtils::FileExists( aNewPath ) )
{
User::LeaveIfError(
Application()->GenerateFileName( fs, aNewPath ));
}
else if ( iCommonUiHelper->IsHostMessagingL() )
{
MPXTlsHelper::SetNeedSave( EFalse );
}
MPX_DEBUG1("CMPXAppUi::CreateAutomaticSavePathL(): exiting");
}
// -----------------------------------------------------------------------------
// HandlePostSaveOperationL
// -----------------------------------------------------------------------------
//
void CMPXAppUi::HandlePostSaveOperationL()
{
MPX_DEBUG1("CMPXAppUi::HandlePostSaveOperationL(): entering");
if ( iSaveMode == EMPXExitAppAfterSave )
{
MPX_DEBUG1( "CMPXAppUi::HandlePostSaveOperationL() exit after save" );
iSaveMode = EMPXSaveModeIdle;
iFile.Close();
RunAppShutter();
}
else if ( iSaveMode == EMPXExitHostAppAfterSave )
{
MPX_DEBUG1( "CMPXAppUi::HandlePostSaveOperationL() exit host app after save" );
iSaveMode = EMPXSaveModeIdle;
iFile.Close();
CAknEnv::RunAppShutter();
}
else
{
MPX_DEBUG1( "CMPXAppUi::HandlePostSaveOperationL() reopen" );
if ( EMPXLaunchModeTrack == MPXTlsHelper::LaunchMode() )
{
if ( iSavePath )
{
iCollectionUiHelper->OpenL( MPXTlsHelper::HostUid(),
*iSavePath,
this,
EMPXCollectionPluginMusic );
delete iSavePath;
iSavePath = NULL;
// User may set ringtone or contact more than once so don't close it after save.
// The iFile.Close will be called at destructor. It is safe because we are
// in Embedded mode.
if ( EMPXLaunchModeTrack != MPXTlsHelper::LaunchMode() )
{
iFile.Close();
}
}
else
{
if ( iFile.SubSessionHandle() )
{
TFileName filename;
iFile.FullName( filename );
iCollectionUiHelper->OpenL( MPXTlsHelper::HostUid(),
filename,
this,
EMPXCollectionPluginMusic );
}
}
}
else
{
if ( iPausedForSave )
{
iPlaybackUtility->CommandL( EPbCmdPlay );
}
}
iSaveMode = EMPXSaveModeIdle;
}
MPX_DEBUG1("CMPXAppUi::HandlePostSaveOperationL(): exiting");
}
// ---------------------------------------------------------------------------
// From MMPXPlaybackObserver
// Handle playback message.
// ---------------------------------------------------------------------------
//
void CMPXAppUi::HandlePlaybackMessage(
CMPXMessage* aMessage, TInt aError )
{
TBool skip = EFalse;
#ifdef __CAMESE_SUPERDISTRIBUTION_SUPPORT
if (aMessage)
{
TMPXMessageId* id( aMessage->Value<TMPXMessageId>( KMPXMessageGeneralId ) );
if ( id )
{
if ( KMPXMessageGeneral == *id )
{
// Prefilter the playback event before passing in to
// AppUi handler.
MPX_TRAP( aError, HandleCamesePlaybackPreProcessingL(*aMessage, skip) );
}
}
}
#endif
if ( !skip && aError == KErrNone && aMessage )
{
TRAP_IGNORE( DoHandlePlaybackMessageL( *aMessage ) );
}
}
// ---------------------------------------------------------------------------
// From MMPXCollectionObserver.
// Handle media properties.
// ---------------------------------------------------------------------------
//
void CMPXAppUi::HandleCollectionMediaL(
const CMPXMedia& aMedia,
TInt aError )
{
MPX_FUNC( "CMPXAppUi::HandleCollectionMediaL" );
TBool okToOpen( ETrue );
const CMPXMedia* media( &aMedia );
// Check if rights OK
if ( !aError )
{
// First make sure it's a DRM file and the file protection type
if ( media->IsSupported( KMPXMediaDrmProtected ) &&
media->IsSupported( KMPXMediaDrmType ) )
{
TBool prot(
media->ValueTObjectL<TBool>( KMPXMediaDrmProtected ) );
if ( prot )
{
#ifdef CAMESE_IN_DRM_UTILITY
// OMA and WMDRM cases will be handled with same logic now
okToOpen = HandleDRMProtectionL(*media);
#else
TMPXMediaDrmType type(
media->ValueTObjectL<TMPXMediaDrmType>( KMPXMediaDrmType ) );
if ( EMPXDrmTypeWMA == type )
{
okToOpen = HandleWMAProtectionL();
}
else
{
okToOpen = HandleDRMProtectionL(*media);
}
#endif
}
}
}
else
{
okToOpen = EFalse;
#ifndef __CAMESE_SUPERDISTRIBUTION_SUPPORT
// Leave Error Handling for Camese Ui
// if Camese support is enabled
iCommonUiHelper->HandleErrorL( aError );
#endif
}
// If all checking passed then open
if ( okToOpen )
{
iCollectionUtility->Collection().OpenL();
}
else if ( MPXTlsHelper::NeedSave() )
{
MPX_DEBUG1( "CMPXAppUi::HandleCollectionMediaL open failed, attempting to save" );
HandleCommandL( EMPXCmdSaveAndExit );
}
}
// ---------------------------------------------------------------------------
// CMPXAppUi::HandleWMAProtectionL
// ---------------------------------------------------------------------------
//
TBool CMPXAppUi::HandleWMAProtectionL()
{
#ifdef __CAMESE_SUPERDISTRIBUTION_SUPPORT
if ( !IsPlaybackRemote() )
{
// Indicates we are currently handling WMA Protected Media
iHandlingProtectedWMAMedia = ETrue;
}
#endif
// Regardless of Camese support enabled or not,
// we always proceed to starting playback of
// protected WMA media.
return ETrue;
}
// ---------------------------------------------------------------------------
// CMPXAppUi::HandleDRMProtectionL
// ---------------------------------------------------------------------------
//
TBool CMPXAppUi::HandleDRMProtectionL(const CMPXMedia& aMedia)
{
TBool okToOpen( ETrue );
// DRM Protection
// Now check the rights status and if it's about to expire.
if ( aMedia.IsSupported( KMPXMediaDrmRightsStatus ) &&
aMedia.IsSupported( KMPXMediaDrmAboutToExpire ) )
{
TMPXMediaDrmRightsStatus status(
aMedia.ValueTObjectL<TMPXMediaDrmRightsStatus>(
KMPXMediaDrmRightsStatus ) );
TBool aboutToExpire(
aMedia.ValueTObjectL<TBool>( KMPXMediaDrmAboutToExpire) );
// Preview clips cannot be saved
if ( EMPXDrmRightsPreview == status )
{
MPXTlsHelper::SetNeedSave( EFalse );
}
RFile* file( NULL );
if ( iFile.SubSessionHandle() &&
MPXTlsHelper::LaunchMode() != EMPXLaunchModePlaylist )
{
file = &iFile;
}
// Display error message if about to expire, or if
// there are no rights
if ( aboutToExpire )
{
TInt ret( iCommonUiHelper->HandleErrorL(
KMPXRightsAboutToExpire, &aMedia, file ));
if ( KErrNone != ret )
{
okToOpen = EFalse;
}
}
else if ( EMPXDrmRightsMissing == status ||
EMPXDrmRightsExpired == status )
{
// DRMStream:
// for silent cases the rights may have been recieved
TInt ret( iCommonUiHelper->HandleErrorL( KErrCANoRights, &aMedia, file ));
if ( KErrNone != ret )
{
okToOpen = EFalse;
}
}
if ( !okToOpen )
{
// If embedded and no rights, then close
if ( IsEmbedded() )
{
// Only close embedded mode if not a playlist
if ( MPXTlsHelper::LaunchMode() != EMPXLaunchModePlaylist )
{
RunAppShutter();
}
else
{
// Reset collection path and save index
MMPXCollection& col( iCollectionUtility->Collection() );
CMPXCollectionPath* cPath( col.PathL() );
CleanupStack::PushL( cPath );
iCurrentIndex = cPath->Index();
cPath->Back();
col.OpenL( *cPath );
CleanupStack::PopAndDestroy( cPath );
}
}
// If standalone and no rights, mark item as invalid
// and reset collection path
else
{
// Check if DRM Flag is already mark as invalid, only set if it's not.
MMPXCollection& col( iCollectionUtility->Collection() );
TBool setDrm( ETrue );
TBool clearOtherFlags( EFalse );
TUint flag( 0 );
if ( aMedia.IsSupported( KMPXMediaGeneralFlags ))
{
flag = aMedia.ValueTObjectL<TUint>( KMPXMediaGeneralFlags );
if ( flag & KMPXMediaGeneralFlagsIsDrmLicenceInvalid )
{
setDrm = EFalse;
}
if ( flag & KMPXMediaGeneralFlagsIsCorrupted ||
flag & KMPXMediaGeneralFlagsIsInvalid )
{
clearOtherFlags = ETrue;
}
}
if ( setDrm )
{
CMPXMedia* entry( CMPXMedia::NewL( aMedia ));
CleanupStack::PushL( entry );
flag = KMPXMediaGeneralFlagsSetOrUnsetBit |
KMPXMediaGeneralFlagsIsDrmLicenceInvalid;
entry->SetTObjectValueL( KMPXMediaGeneralFlags, flag );
SetMediaL( *entry );
CleanupStack::PopAndDestroy( entry );
}
// Reset corrupted and invalid flags if they are set
if ( clearOtherFlags )
{
CMPXMedia* entry( CMPXMedia::NewL( aMedia ));
CleanupStack::PushL( entry );
flag = KMPXMediaGeneralFlagsIsCorrupted |
KMPXMediaGeneralFlagsIsInvalid;
entry->SetTObjectValueL( KMPXMediaGeneralFlags, flag );
SetMediaL( *entry );
CleanupStack::PopAndDestroy( entry );
}
// Reset collection path and save index
CMPXCollectionPath* cPath( col.PathL() );
CleanupStack::PushL( cPath );
iCurrentIndex = cPath->Index();
cPath->Back();
col.OpenL( *cPath );
CleanupStack::PopAndDestroy( cPath );
}
}
}
else
{
// If rights status and about to expire attributes are
// not set, retrieve them.
RArray<TMPXAttribute> attrs;
CleanupClosePushL(attrs);
attrs.Append( TMPXAttribute( KMPXMediaIdGeneral,
EMPXMediaGeneralBasic |
EMPXMediaGeneralUri |
EMPXMediaGeneralFlags |
EMPXMediaGeneralCollectionId |
EMPXMediaGeneralId ));
attrs.Append( KMPXMediaDrmAll );
CMPXCollectionPath* cPath = iCollectionUtility->Collection().PathL();
CleanupStack::PushL( cPath );
iCollectionUtility->Collection().MediaL(
*cPath,
attrs.Array() );
CleanupStack::PopAndDestroy( cPath );
CleanupStack::PopAndDestroy( &attrs );
okToOpen = EFalse;
}
return okToOpen;
}
// ---------------------------------------------------------------------------
// Handle Broadcast messages from the collection
// ---------------------------------------------------------------------------
//
void CMPXAppUi::HandleBroadcastMessageL( const CMPXMessage& aMessage )
{
// Disable media keys during system operations.
TInt op( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralType ) );
MPX_DEBUG2( "CMPXAppUi::HandleBroadcastMessageL EBroadcastEvent, op = %d", op );
if( op == EMcMsgUSBMassStorageStart ||
op == EMcMsgUSBMTPStart ||
op == EMcMsgRefreshStart ||
op == EMcMsgFormatStart )
{
MPX_DEBUG1( "CMPXAppUi::HandleBroadcastMessageL EBroadcastEvent disable media key" );
if ( !IsEmbedded() || op != EMcMsgUSBMTPStart )
{
iMediaKeyHandler->SetEnableMediaKeys( EFalse );
}
}
else if( op == EMcMsgUSBMassStorageEnd ||
op == EMcMsgUSBMTPEnd ||
op == EMcMsgRefreshEnd ||
op == EMcMsgFormatEnd )
{
MPX_DEBUG1( "CMPXAppUi::HandleBroadcastMessageL EBroadcastEvent enable media key" );
if ( !IsEmbedded() || op != EMcMsgUSBMTPEnd )
{
iMediaKeyHandler->SetEnableMediaKeys( ETrue );
}
}
if (op == EMcMsgRefreshEnd)
{
TInt err = aMessage.ValueTObjectL<TInt>(KMPXMessageGeneralData);
MPX_DEBUG2("EMcMsgRefreshEnd, err = %d", err);
if (err < KErrNone)
iCommonUiHelper->HandleErrorL(err);
}
// Re-open the path so that the view can be refreshed,
// because there could be changes in the view contents
//
if ( op == EMcMsgUSBMassStorageStart ||
op == EMcMsgUSBMTPStart )
{
iIsUsbOnGoing = ETrue;
if ( iProcessParameter )
{
iProcessParameter->SetUsbInUse( ETrue );
}
}
if ( op == EMcMsgUSBMassStorageEnd ||
op == EMcMsgUSBMTPEnd )
{
iIsUsbOnGoing = EFalse;
if ( iProcessParameter )
{
iProcessParameter->SetUsbInUse( EFalse );
}
if( op == EMcMsgUSBMTPEnd )
{
DoUpdatePluginRefreshedTimeL();
}
}
if( op == EMcMsgFormatStart )
{
iFormattingOnGoing = ETrue;
}
else if( op == EMcMsgFormatEnd )
{
iFormattingOnGoing = EFalse;
}
else if ( op == EMcMsgRefreshStart )
{
iRefreshOnGoing = ETrue;
if( iProcessParameter )
{
iProcessParameter->SetRefreshState( ETrue );
}
}
else if ( op == EMcMsgRefreshEnd )
{
iRefreshOnGoing = EFalse;
if( iProcessParameter )
{
iProcessParameter->SetRefreshState( EFalse );
}
}
if ( op == EMcMsgUSBMTPEnd )
{
if ( !IsEmbedded() )
{
CMPXCollectionPath* cPath = iCollectionUtility->Collection().PathL ( );
CleanupStack::PushL ( cPath );
TBool usbDiskRemovalEvent(EFalse);
if ( (op == EMcMsgDiskRemoved) && iIsUsbOnGoing )
{
usbDiskRemovalEvent = ETrue;
}
if ( cPath->Levels ( )> 1 && !iFormattingOnGoing && !usbDiskRemovalEvent &&
iCurrentViewType.iUid != KMPXPluginTypePlaybackUid &&
iCurrentViewType.iUid != KMPXPluginTypeAudioEffectsUid )
{
cPath->Back ( );
iCollectionUtility->Collection().OpenL ( *cPath );
}
CleanupStack::PopAndDestroy ( cPath );
}
}
else if ( op == EMcMsgDiskRemoved )
{
if ( !IsEmbedded() )
{
TBool usbDiskRemovalEvent(EFalse);
if ( (op == EMcMsgDiskRemoved) && iIsUsbOnGoing )
{
usbDiskRemovalEvent = ETrue;
}
else
{
MPX_DEBUG1( "CMPXAppUi::HandleBroadcastMessageL. MMC ejected and the application needs to close." );
RunAppShutter();
return;
}
CMPXCollectionPath* cPath = iCollectionUtility->Collection().PathL ( );
CleanupStack::PushL ( cPath );
if ( cPath->Levels ( )> 1 && !iFormattingOnGoing && !usbDiskRemovalEvent &&
iCurrentViewType.iUid != KMPXPluginTypePlaybackUid )
{
cPath->Back ( );
iCollectionUtility->Collection().OpenL ( *cPath );
}
CleanupStack::PopAndDestroy ( cPath );
}
}
// Re-open the collection view after a refresh
// and after album art or metadata dialog or add songs editor dialog closes
if (((op == EMcMsgRefreshEnd ) || (op == EMcMsgUSBMassStorageEnd))
&& (IsActiveView(KMPXPluginTypeAlbumArtEditorUid)
|| IsActiveView(KMPXPluginTypeMetadataEditorUid)
|| IsActiveView( KMPXPluginTypeAddSongsEditorUid ) ) )
{
if ( !IsEmbedded() )
{
iRefreshCollectionView = ETrue;
}
}
// Re-open the collection view after a refresh
// if we were currently in collection view.
if( op == EMcMsgRefreshEnd && IsActiveView(KMPXPluginTypeCollectionUid))
{
if( !IsEmbedded() )
{
iRefreshCollectionView = EFalse;
CMPXCollectionPath* path = iCollectionUtility->Collection().PathL();
CleanupStack::PushL( path );
if( path->Levels() > 1 &&
iCurrentViewType.iUid != KMPXPluginTypePlaybackUid )
{
path->Back();
iCollectionUtility->Collection().OpenL( *path );
}
CleanupStack::PopAndDestroy( path );
}
}
}
// ---------------------------------------------------------------------------
// Handles commands passed in by other applications
// ---------------------------------------------------------------------------
//
void CMPXAppUi::HandleCommandParametersL( const TDesC8& aCommand )
{
MPX_FUNC( "CMPXAppUi::HandleCommandParametersL" );
if ( !iIgnoreExternalCommand && aCommand.Size() > 0 )
{
delete iProcessParameter;
iProcessParameter = NULL;
TUid collectionMode( KAppUidMusicPlayerX );
if ( IsEmbedded() )
{
collectionMode = MPXTlsHelper::HostUid(); // Collection context == host UID
}
iProcessParameter = CMPXCommandHandler::NewL(
iPlaybackUtility, collectionMode, aCommand );
TBool fwdStandAlone( iProcessParameter->ForwardCmdToStandAloneMode() );
TBool fwdNowPlaying( iProcessParameter->ForwardCmdToNowPlaying() );
MPX_DEBUG2( "CMPXAppUi::HandleCommandParametersL iIsUsbOnGoing = %d", iIsUsbOnGoing );
// if ActiveIdle plugin sends a command i.e., EMPXCmdFwdNowPlaying, it doesn't make any dialogs dismiss.
if ( !fwdNowPlaying && iCurrentViewType.iUid != KMPXPluginTypeWaitNoteDialogUid && !iIsUsbOnGoing )
{
MPX_DEBUG1( "CMPXAppUi::HandleCommandParametersL dismissing dialogs" );
// dismiss all the dialogs except scaning wait note
AknDialogShutter::ShutDialogsL( *CEikonEnv::Static() );
}
iCmdActivatedViewTypeId = iProcessParameter->ActivatedViewTypeId();
MPX_DEBUG2( "CMPXAppUi::HandleCommandParametersL activated view type= =0x%x",
iCmdActivatedViewTypeId );
MPX_DEBUG3( "CMPXAppUi::HandleCommandParametersL should forward to standalone %d, now playing %d", fwdStandAlone, fwdNowPlaying );
RArray<TProcessId> procArray;
CleanupClosePushL( procArray );
TProcessId npProcId( 0 );
MMPXPlaybackUtility* activePbU = MMPXPlaybackUtility::UtilityL( KPbModeActivePlayer );
activePbU->GetClientsL( procArray );
activePbU->Close();
npProcId = procArray[ 0 ];
CleanupStack::PopAndDestroy( &procArray );
TInt64 standAlonePId( CMPXCommonUiHelper::StandAloneModePId() );
RProcess currProc;
TProcessId currPId( currProc.Id() );
currProc.Close();
MPX_DEBUG2( "CMPXAppUi::HandleCommandParametersL current pid 0x%lx", currPId.Id() );
MPX_DEBUG2( "CMPXAppUi::HandleCommandParametersL nppid 0x%lx", npProcId.Id() );
MPX_DEBUG2( "CMPXAppUi::HandleCommandParametersL standalone pid 0x%lx", standAlonePId );
if ( ( !fwdStandAlone && !fwdNowPlaying ) || // no forward
( fwdStandAlone && ( currPId.Id() == standAlonePId ) ) || // we're standalone mode
( fwdNowPlaying && ( currPId == npProcId ) ) ) // we are now playing
{
if ( iPathRestore )
{
if ( !iPathRestore->Initialized() &&
iProcessParameter->IsInitPlaybackEngineNeeded() )
{
if ( iPathRestore->IsInitializing() )
{
MPX_DEBUG1( "CMPXAppUi::HandleCommandParametersL command handling delayed until path restore completes" );
// delay command processing until path restore is complete
iDelayedParameterHandling = ETrue;
}
else
{
MPX_DEBUG1( "CMPXAppUi::HandleCommandParametersL canceling path restore" );
// command will init playback engine, can cancel path restore's init
iPathRestore->CancelInit();
}
}
}
if ( !iDelayedParameterHandling )
{
// command should be handled locally
iProcessParameter->ProcessMessageL( iIsUsbOnGoing, iRefreshOnGoing, iFormattingOnGoing );
}
}
else
{
TInt64 procId( 0 );
if ( iProcessParameter->ForwardCmdToStandAloneMode() )
{
MPX_DEBUG1( "CMPXAppUi::HandleCommandParametersL forwarding to standalone" );
procId = standAlonePId;
}
else if ( iProcessParameter->ForwardCmdToNowPlaying() )
{
MPX_DEBUG1( "CMPXAppUi::HandleCommandParametersL forwarding to now playing" );
procId = npProcId.Id();
}
delete iProcessParameter;
iProcessParameter = NULL;
if ( procId != 0 )
{
// standalone music player exist, forward command to it
RWsSession& wsSession( iCoeEnv->WsSession() );
TInt wgId( MPXUser::FindWindowGroupIdL( procId, wsSession ) );
MPX_DEBUG2( "CMPXAppUi::HandleCommandParametersL() forwarding message to wgId 0x%x", wgId );
wsSession.SendMessageToWindowGroup( wgId, KAppUidMusicPlayerX, aCommand );
}
else
{
MPX_DEBUG1( "CMPXAppUi::HandleCommandParametersL no music player instance, starting a new one" );
// no music player instance, start a new one
RApaLsSession ls;
CleanupClosePushL( ls );
User::LeaveIfError( ls.Connect() );
TApaAppInfo appInfo;
User::LeaveIfError( ls.GetAppInfo( appInfo, KAppUidMusicPlayerX ) );
CApaCommandLine* apaCommandLine = CApaCommandLine::NewLC();
apaCommandLine->SetExecutableNameL( appInfo.iFullName );
apaCommandLine->SetTailEndL( aCommand );
User::LeaveIfError( ls.StartApp( *apaCommandLine ) );
CleanupStack::PopAndDestroy(); // apaCommandLine
CleanupStack::PopAndDestroy(); // ls
}
}
}
else if ( iIgnoreExternalCommand )
{
MPX_DEBUG1( "CMPXAppUi::HandleCommandParametersL command to be ignored, requested by views" );
// bring musicplayer to foreground
// have to use window group to activate, in case some other window
// has higher priority than us (e.g. playback popup and volume popup)
RWindowGroup myWin = CEikonEnv::Static()->RootWin();
myWin.SetOrdinalPosition( 0, ECoeWinPriorityNormal );
}
else
{
MPX_DEBUG1( "CMPXAppUi::HandleCommandParametersL invalid parameter length, command ignored" );
}
}
// ---------------------------------------------------------------------------
// Handle playback message.
// ---------------------------------------------------------------------------
//
void CMPXAppUi::DoHandlePlaybackMessageL(
const CMPXMessage& aMessage )
{
MPX_FUNC( "CMPXAppUi::DoHandlePlaybackMessageL" );
TMPXMessageId id( aMessage.ValueTObjectL<TMPXMessageId>( KMPXMessageGeneralId ) );
if ( KMPXMessageGeneral == id )
{
switch ( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralEvent ) )
{
case TMPXPlaybackMessage::EPlayerChanged:
{
MPX_DEBUG1( "CMPXAppUi::DoHandlePlaybackMessageL EPlayerChanged" );
// get the current Volume and Max Volume
iPlaybackUtility->PropertyL(*this, EPbPropertyVolume);
iPlaybackUtility->PropertyL(*this, EPbPropertyMaxVolume);
HandlePlaybackPlayerChangedL();
break;
}
case TMPXPlaybackMessage::EInitializeComplete:
{
MPX_DEBUG1( "CMPXAppUi::DoHandlePlaybackMessageL init complete" );
TInt data( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralData ) );
if ( ( IsEmbedded() || iPathRestore && iPathRestore->Initialized() ) && data )
{
TMPXLaunchMode mode = MPXTlsHelper::LaunchMode();
if ( EMPXLaunchModeStopped != mode &&
EMPXLaunchModeUnknown!= mode )
{
// Play the track
MPX_DEBUG1( "CMPXAppUi::DoHandlePlaybackMessageL send play command" );
CMPXCommand* cmd( CMPXCommand::NewL() );
CleanupStack::PushL( cmd );
cmd->SetTObjectValueL<TInt>( KMPXCommandGeneralId,
KMPXCommandIdPlaybackGeneral );
cmd->SetTObjectValueL<TInt>( KMPXCommandPlaybackGeneralType,
EPbCmdPlay );
cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync,
ETrue );
cmd->SetTObjectValueL<TBool>( KMPXCommandPlaybackGeneralNoBuffer,
ETrue );
iPlaybackUtility->CommandL( *cmd );
CleanupStack::PopAndDestroy( cmd );
}
}
else // iPathRestore not initialized
{
if ( iPathRestore )
{
iPathRestore->SetInitialized( ETrue );
}
if ( iStandAlone )
{
iPlaybackUtility->CommandL( EPbCmdPlay );
}
if ( iDelayedParameterHandling )
{
MPX_DEBUG1( "CMPXAppUi::DoHandlePlaybackMessageL start command handling" );
iDelayedParameterHandling = EFalse;
iProcessParameter->ProcessMessageL( iIsUsbOnGoing, iRefreshOnGoing, iFormattingOnGoing );
}
}
break;
}
case TMPXPlaybackMessage::EPlayerUnavailable:
{
MPX_DEBUG1( "CMPXAppUi::DoHandlePlaybackMessageL EPlayerUnavailable" );
iUPnPUnavailableEventFromCollection = EFalse;
MMPXSource* source = iPlaybackUtility->Source();
if ( source )
{
CMPXCollectionPlaylist* playlist = source->PlaylistL();
if ( playlist )
{
CleanupStack::PushL( playlist );
iPlaybackUtility->PlayerManager().ClearSelectPlayersL();
MPX_DEBUG2( "CMPXAppUi::DoHandlePlaybackMessageL playlist index = %d", playlist->Index());
iPlaybackUtility->InitL( *playlist, ETrue );
CleanupStack::PopAndDestroy( playlist );
}
}
if ( iCurrentViewType.iUid != KMPXPluginTypePlaybackUid )
{
iUPnPUnavailableEventFromCollection = ETrue;
}
break;
}
case TMPXPlaybackMessage::EPropertyChanged:
{
TInt type( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralType ) );
TMPXPlaybackProperty property(
static_cast<TMPXPlaybackProperty>( type ) );
if ( property == EPbPropertyVolume )
{
iCurrentVolume = aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralData );
MPX_DEBUG2( "CMPXAppUi::DoHandlePlaybackMessageL iCurrentVolume = %d", iCurrentVolume );
}
else if( property == EPbPropertyRandomMode
|| property == EPbPropertyRepeatMode )
{
TInt value = aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralData );
TUint32 key = KMPXMPPlaybackRandomMode;
if( property == EPbPropertyRepeatMode )
{
key = KMPXMPPlaybackRepeatMode;
}
MPX_DEBUG3( "CMPXAppUi::DoHandlePlaybackMessageL EPropertyChanged key = %d, value = %d", key, value );
CRepository* repository = CRepository::NewL( KCRUidMPXMPSettings );
repository->Set( key, value );
delete repository;
repository = NULL;
}
break;
}
case TMPXPlaybackMessage::EStateChanged:
{
TInt type( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralType ) );
TMPXPlaybackState state(
static_cast<TMPXPlaybackState>( type ) );
#ifndef FF_OOM_MONITOR2_COMPONENT
// Obtain wgname
// Gets the window group id of the app in foreground
RWsSession& wsSession( iCoeEnv->WsSession() );
RWindowGroup myWin = iEikonEnv->RootWin();
CApaWindowGroupName* wgName = CApaWindowGroupName::NewLC( wsSession, myWin.Identifier() );
#endif //FF_OOM_MONITOR2_COMPONENT
switch( state )
{
case EPbStateInitialising:
case EPbStatePlaying:
case EPbStatePaused:
case EPbStateSeekingForward:
case EPbStateSeekingBackward:
case EPbStateBuffering:
case EPbStateDownloading:
{
#ifdef FF_OOM_MONITOR2_COMPONENT
SetMpxOomPriorityL( ROomMonitorSession::EOomPriorityBusy );
#else
wgName->SetBusy(ETrue);
#endif //FF_OOM_MONITOR2_COMPONENT
break;
}
case EPbStateNotInitialised:
case EPbStateStopped:
case EPbStateShuttingDown:
{
#ifdef FF_OOM_MONITOR2_COMPONENT
SetMpxOomPriorityL( ROomMonitorSession::EOomPriorityNormal );
#else
wgName->SetBusy(EFalse);
#endif //FF_OOM_MONITOR2_COMPONENT
break;
}
default:
{
break;
}
}
#ifndef FF_OOM_MONITOR2_COMPONENT
CleanupStack::PopAndDestroy(); //wgName
#endif //FF_OOM_MONITOR2_COMPONENT
break;
}
case TMPXPlaybackMessage::EError:
{
MPX_DEBUG2( "CMPXAppUi::DoHandlePlaybackMessageL error = %d", aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralData ) );
break;
}
default:
{
break;
}
}
}
}
#ifdef __CAMESE_SUPERDISTRIBUTION_SUPPORT
// ---------------------------------------------------------------------------
// Handle Camese Playback Message Preprocessing
// ---------------------------------------------------------------------------
//
void CMPXAppUi::HandleCamesePlaybackPreProcessingL(const CMPXMessage& aMessage,
TBool& aSkipEvent)
{
aSkipEvent = EFalse;
// Pre-filter events, avoiding handling if Camese
// is handling WMA songs in pre-init phase.
if (iHandlingProtectedWMAMedia)
{
TInt event = aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralEvent );
if (event == TMPXPlaybackMessage::EPlayerChanged)
{
MPX_DEBUG1("CMPXAppUi::HandleCamesePlaybackPreProcessingL EPlayerChanged");
// Do not allow processing of the player changed stage
// to avoid view switching.
aSkipEvent = ETrue;
}
else if (event == TMPXPlaybackMessage::EInitializeComplete)
{
MPX_DEBUG1("CMPXAppUi::HandleCamesePlaybackPreProcessingL EStateChanged EInitializeComplete");
// Execute view switching now.
HandlePlaybackPlayerChangedL();
// Finished Protected Media Handling stage.
iHandlingProtectedWMAMedia = EFalse;
}
else if (event == TMPXPlaybackMessage::EError)
{
MPX_DEBUG2( "CMPXAppUi::HandleCamesePlaybackPreProcessingL error = %d", aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralData ) );
// Finished Protected Media Handling stage.
iHandlingProtectedWMAMedia = EFalse;
}
}
}
#endif
// ---------------------------------------------------------------------------
// Handle playback message for player changed.
// ---------------------------------------------------------------------------
//
void CMPXAppUi::HandlePlaybackPlayerChangedL()
{
// Don't switch views if we are getting player changed
// event from path restore or when we switch player because of a UPnP
// Unavailable event in Collection view
//
if ( !iUPnPUnavailableEventFromCollection &&
( IsEmbedded() || iPathRestore ) )
{
if( iPathRestore && !iPathRestore->Initialized() )
{
iPathRestore->CancelInit();
}
MMPXPlayer* player =
iPlaybackUtility->PlayerManager().CurrentPlayer();
TUid pluginUid( KNullUid );
RArray<TUid> array;
CleanupClosePushL( array );
if ( player )
{
pluginUid = player->UidL();
MPX_DEBUG2( "CMPXAppUi::HandlePlaybackPlayerChangedL pluginUid uid = 0x%x", pluginUid.iUid );
array.AppendL( pluginUid );
}
MMPXSource* source = iPlaybackUtility->Source();
if ( source )
{
CMPXCollectionPlaylist* playlist = source->PlaylistL();
if ( playlist )
{
CleanupStack::PushL( playlist );
CMPXCollectionPath* pbPath =
CMPXCollectionPath::NewL( playlist->Path() );
CleanupStack::PushL( pbPath );
if ( pbPath->Levels() > 0 )
{
MPX_DEBUG2( "CMPXAppUi::HandlePlaybackPlayerChangedL collection uid = 0x%x", pbPath->Id( 0 ).iId1 );
array.AppendL( TUid::Uid( pbPath->Id( 0 ) ) );
}
CleanupStack::PopAndDestroy( pbPath );
CleanupStack::PopAndDestroy( playlist );
}
}
if ( IsEmbedded() )
{
array.AppendL( TUid::Uid( KMPXPluginTypeEmbeddedPlaybackUid ));
}
else
{
array.AppendL( TUid::Uid( KMPXPluginTypePlaybackUid ) );
}
iViewUtility->ActivateViewL( array );
CleanupStack::PopAndDestroy( &array );
MPX_DEBUG2( "-->Plugin Uid:(%d)", pluginUid.iUid );
}
iUPnPUnavailableEventFromCollection = EFalse;
}
// ---------------------------------------------------------------------------
// Callback function to signal that saving a file is complete
// ---------------------------------------------------------------------------
//
void CMPXAppUi::DoHandleSaveCompleteL( TInt aErr )
{
MPX_DEBUG2("CMPXAppUi::DoHandleSaveCompleteL(%d) entering", aErr);
if( iIsUsbOnGoing && (aErr != KErrNone) )
{
// Kill mpx embedded mode so usb can start
//
MPX_DEBUG1("CMPXAppUi::HandleAddFileCompleteL usb ongoing");
iSaveMode = EMPXExitAppAfterSave;
HandlePostSaveOperationL();
}
else if ( !iCancelFileMan )
{
if ( !aErr )
{
if ( !iCollectionHelper )
{
iCollectionHelper = CMPXCollectionHelperFactory::NewCollectionHelperL();
}
iCollectionHelper->AddL( *iSavePath, this );
if ( iView )
{
if ( iSaveMode == EMPXAssignRingtone )
{
TRAP_IGNORE(
MPXTlsHelper::SetFilePath( iSavePath->Des() );
iView->HandleCommandL( EMPXCmdAfterSaveAiwCmdAssign ));
MPXTlsHelper::SetNeedSave( EFalse );
}
else if ( iSaveMode == EMPXAssignContact )
{
TRAP_IGNORE(
iView->HandleCommandL( EMPXCmdAfterSaveUseAsCascade ));
MPXTlsHelper::SetNeedSave( EFalse );
}
}
}
else
{
iCommonUiHelper->DismissWaitNoteL();
iCommonUiHelper->HandleErrorL( aErr );
delete iSavePath;
iSavePath = NULL;
if ( iView )
{
iView->HandleCommandL( EMPXCmdSaveCancelled );
}
HandlePostSaveOperationL();
}
}
else
{
MPX_DEBUG1("CMPXAppUi::DoHandleSaveCompleteL() during cancel, starting callback" );
iIdle = CIdle::NewL( CActive::EPriorityIdle );
iSaveMode = EMPXSaveModeIdle;
iIdle->Start( TCallBack( CMPXAppUi::DeferredExitCallback, this ) );
}
MPX_DEBUG1("CMPXAppUi::DoHandleSaveCompleteL() exiting" );
}
// -----------------------------------------------------------------------------
// Handle collection message
// -----------------------------------------------------------------------------
//
void CMPXAppUi::DoHandleCollectionMessageL( const CMPXMessage& aMessage )
{
MPX_FUNC( "CMPXAppUi::DoHandleCollectionMessageL" );
TMPXMessageId id( aMessage.ValueTObjectL<TMPXMessageId>( KMPXMessageGeneralId ) );
if ( KMPXCustomMessageId == id )
{
// This is a custom collection message
//
TInt colId = aMessage.ValueTObjectL<TInt>( TMPXAttribute( KMPXCustomMessageId,
EMPXCustomMessageCollectionId ) );
TInt op = aMessage.ValueTObjectL<TInt>( TMPXAttribute( KMPXCustomMessageId,
EMPXCustomMessageEventType ) );
TInt err = aMessage.ValueTObjectL<TInt>( TMPXAttribute( KMPXCustomMessageId,
EMPXCustomMessageErrorCode ) );
MPX_DEBUG4("CMPXAppUi::DoHandleCollectionMessageL -- KMPXCustomMessageId \
%i %i %i", colId, op, err);
if( colId == iMusicCollectionId.iUid ||
colId == iPodcastCollectionId.iUid )
{
if( op == EMcsOpen )
{
// @todo, need UI spec
// popup special error note for out of disk
iCommonUiHelper->HandleErrorL( err );
}
}
}
else if ( KMPXMessageGeneral == id )
{
TInt event( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralEvent ) );
TInt type( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralType ) );
TInt data( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralData ) );
MPX_DEBUG3( "CMPXAppUi::DoHandleCollectionMessageL Event = %d, Type() = %d",
event, type );
if ( event == TMPXCollectionMessage::ECollectionChanged && !SuppressCollectionView() )
{
MPX_DEBUG1( "CMPXAppUi::DoHandleCollectionMessageL ECollectionChanged" );
if ( EMPXLaunchModeTrack != MPXTlsHelper::LaunchMode() )
{
CMPXCollectionPath* cPath = iCollectionUtility->Collection().PathL();
CleanupStack::PushL( cPath );
if ( cPath->Levels() != 1 )
{
RArray<TUid> uids;
CleanupClosePushL( uids );
if ( iLaunchModePlaying && EMPXLaunchModePlaylist == MPXTlsHelper::LaunchMode() )
{
iLaunchModePlaying = EFalse;
cPath->SelectL(TMPXItemId(0));
iCollectionUtility->Collection().OpenL( *cPath );
}
else
{
uids.AppendL( TUid::Uid( KMPXPluginTypeCollectionUid ) );
uids.AppendL( TUid::Uid( data ) );
}
// If transitioning from Now Playing to Collection view,
// We have to set the selection index
// Only applicable if path levels is > 2, ie not music / podcast menu
//
if( iCurrentViewType.iUid == KMPXPluginTypePlaybackUid )
{
MMPXSource* s = iPlaybackUtility->Source();
if( s && cPath->Levels() > 2 )
{
CMPXCollectionPlaylist* pl = s->PlaylistL();
TInt browsePathCount = cPath->Count();
if( pl )
{
CleanupStack::PushL( pl );
if( browsePathCount > 0 ) // don't set index since this playlist
// no longer contains any items, this can
// happen in the case of autoplaylists and cause
// a hang
{
TInt playlistIndex = pl->Path().Index();
if(playlistIndex < browsePathCount)
{
iCollectionUtility->Collection().CommandL(EMcCmdSelect,
playlistIndex);
}
}
CleanupStack::PopAndDestroy( pl );
}
}
}
// Activate the collection view
MPX_DEBUG2( "CMPXAppUi::DoHandleCollectionMessageL cpath depth = %d", cPath->Levels() );
// only activate collection view when it's not at plugin selection
// screen, it is handled by main view
#ifdef RD_BROWSER_PROGRESSIVE_DOWNLOAD
icollectionBrowsed = ETrue;
#endif // RD_BROWSER_PROGRESSIVE_DOWNLOAD
iViewUtility->ActivateViewL( uids );
CleanupStack::PopAndDestroy( &uids );
}
CleanupStack::PopAndDestroy( cPath );
}
}
else if ( event == TMPXCollectionMessage::EPathChanged &&
!SuppressCollectionView() &&
type == EMcPathChangedByOpen &&
data == EMcItemOpened)
{ // Open new entries
MPX_DEBUG1( "CMPXAppUi::HandleCollectionMessageL EPathChanged EMcItemOpened" );
// First get media to check for protected state
RArray<TMPXAttribute> attrs;
CleanupClosePushL(attrs);
attrs.Append( TMPXAttribute( KMPXMediaIdGeneral,
EMPXMediaGeneralBasic |
EMPXMediaGeneralUri ));
attrs.Append( TMPXAttribute( KMPXMediaIdDrm,
EMPXMediaDrmType |
EMPXMediaDrmProtected ));
CMPXCollectionPath* cPath = iCollectionUtility->Collection().PathL();
CleanupStack::PushL( cPath );
if( cPath->Count() > 0 )
{
iCollectionUtility->Collection().MediaL(
*cPath,
attrs.Array() );
}
else
{
// OpenL the blank playlist
iCollectionUtility->Collection().OpenL();
}
// Default start up state for local playback is Playing
MPXTlsHelper::SetLaunchModeL( EMPXLaunchModePlaying );
CleanupStack::PopAndDestroy( cPath );
CleanupStack::PopAndDestroy( &attrs );
}
else if( event == TMPXCollectionMessage::EPathChanged &&
!SuppressCollectionView() &&
type == EMcPathChangedByOpen &&
data == EMcContainerOpened &&
( iCurrentViewType.iUid == KMPXPluginTypePlaybackUid ||
iCurrentViewType.iUid == KMPXPluginTypeEmbeddedPlaybackUid ||
iCurrentViewType.iUid == KMPXPluginTypeAudioEffectsUid ||
iCurrentViewType.iUid == KMPXPluginTypeEqualizerUid) )
{
MPX_DEBUG1( "CMPXAppUi::HandleCollectionMessageL EPathChanged EMcContainerOpened" );
CMPXCollectionPath* cPath = iCollectionUtility->Collection().PathL();
CleanupStack::PushL( cPath );
TInt levels( cPath->Levels() );
if ( levels != 1 )
{
iDeferredViewActivationUid.Reset();
if ( iLaunchModePlaying && EMPXLaunchModePlaylist == MPXTlsHelper::LaunchMode() )
{
iLaunchModePlaying = EFalse;
cPath->SelectL(TMPXItemId(0));
iCollectionUtility->Collection().OpenL( *cPath );
}
else
{
iDeferredViewActivationUid.AppendL( TUid::Uid( KMPXPluginTypeCollectionUid ) );
iDeferredViewActivationUid.AppendL( TUid::Uid( data ) );
}
// add the collection uid to make sure the correct view is
// activated
if ( levels > 0 )
{
iDeferredViewActivationUid.AppendL( TUid::Uid( cPath->Id( 0 ) ) );
}
// Set selection to playlist index if transitioning from
// playback to collection view
// Only applicable if path levels is > 2, ie not music / podcast menu
//
MMPXSource* s = iPlaybackUtility->Source();
if( s && levels > 2 )
{
CMPXCollectionPlaylist* pl = s->PlaylistL();
TInt browsePathCount = cPath->Count();
// don't set index since this playlist
// no longer contains any items, this can
// happen in the case of autoplaylists and cause
// a hang
//
// Make sure we are the same level and the same container before making index call
//
if( pl )
{
CleanupStack::PushL( pl );
if ( browsePathCount > 0 &&
levels == pl->Path().Levels() &&
cPath->Id(levels-2) == pl->Path().Id(levels-2) )
{
TInt playlistIndex = pl->Path().Index();
if(playlistIndex < browsePathCount)
{
iCollectionUtility->Collection().CommandL(EMcCmdSelect,
playlistIndex);
}
}
CleanupStack::PopAndDestroy( pl );
}
}
MPX_DEBUG2( "CMPXAppUi::HandleCollectionMessageL cpath depth = %d", cPath->Levels() );
if ( IsForeground() )
{
MPX_DEBUG3( "CMPXAppUi::HandleCollectionMessageL Activating view now CurUid=0x%x, DefUid=0x%x", iCurrentViewType.iUid, iDeferredViewActivationUid[iDeferredViewActivationUid.Count()-1].iUid);
// only activate collection view when it's not at plugin selection
// screen, it is handled by main view
iViewUtility->ActivateViewL( iDeferredViewActivationUid );
iDeferredViewActivationUid.Reset();
}
else
{
MPX_DEBUG1( "CMPXAppUi::HandleCollectionMessageL musicplayer in background, deferred view activation" );
}
}
CleanupStack::PopAndDestroy( cPath );
}
else if( event == TMPXCollectionMessage::EPathChanged &&
type == EMcPathChangedByOpen &&
data == EMcContainerOpened )
{
MPXTlsHelper::SetLaunchModeL( EMPXLaunchModePlaying );
CMPXCollectionPath* cPath = iCollectionUtility->Collection().PathL();
CleanupStack::PushL( cPath );
if ( cPath->Levels() == 1 && !IsEmbedded() &&
iCurrentViewType.iUid != KMPXPluginTypeMainUid &&
iCurrentViewType.iUid != KMPXPluginTypeWaitNoteDialogUid &&
!SuppressCollectionView() )
{
// activate main view if other clients navigated to first level
if ( IsForeground() )
{
MPX_DEBUG1( "CMPXAppUi::HandleCollectionMessageL Switching to main view" );
iViewUtility->ActivateViewL(
TUid::Uid( KMPXPluginTypeMainUid ) );
}
else
{
MPX_DEBUG1( "CMPXAppUi::HandleCollectionMessageL musicplayer in background, deferred view activation" );
iDeferredViewActivationUid.Reset();
iDeferredViewActivationUid.Append( TUid::Uid( KMPXPluginTypeMainUid ) );
}
}
TInt level(2);
if ( iStartInAlbumMenu )
{
level = 3;
}
#ifdef __ENABLE_PODCAST_IN_MUSIC_MENU
// Music Player opens directly at level 2 so we need to initialize
// the path then
if( cPath->Levels() == level && iPathRestore && !iPathRestore->Initialized() && !iStandAlone )
#else
if( cPath->Levels() == 1 && iPathRestore && !iPathRestore->Initialized() )
#endif
{
if ( iProcessParameter )
{
if ( !iProcessParameter->IsPathInited() )
{
MPX_DEBUG1( "CMPXAppUi::HandleCollectionMessageL load path" );
iPathRestore->LoadPathL();
}
else
{
MPX_DEBUG1( "CMPXAppUi::HandleCollectionMessageL path inited by command handler, not restore path" );
}
}
else
{
MPX_DEBUG1( "CMPXAppUi::HandleCollectionMessageL load path" );
iPathRestore->LoadPathL();
}
}
else if ( iCurrentIndex != KErrNotFound )
{
iCollectionUtility->Collection().CommandL( EMcCmdSelect, iCurrentIndex );
iCurrentIndex = KErrNotFound;
iCollectionUtility->Collection().OpenL();
}
CleanupStack::PopAndDestroy( cPath );
}
else if( event == TMPXCollectionMessage::EBroadcastEvent )
{
HandleBroadcastMessageL( aMessage );
}
}
}
// -----------------------------------------------------------------------------
// CMPXAppUi::IsPlaybackRemote
// -----------------------------------------------------------------------------
//
TBool CMPXAppUi::IsPlaybackRemote()
{
TBool isRemote = EFalse;
TMPXPlaybackPlayerType type( EPbLocal );
TUid uid;
TInt index;
MMPXPlayerManager& manager = iPlaybackUtility->PlayerManager();
HBufC* subPlayerName = NULL;
TRAP_IGNORE( manager.GetSelectionL( type, uid, index, subPlayerName ) );
delete subPlayerName;
//#ifdef __UPNP_FRAMEWORK_2_0_
if ( FeatureManager::FeatureSupported( KFeatureIdUpnpFramework20 ) )
{
// Check for Remote, since in embedded mode
// playback utility will report type as Unknown.
if ( type == EPbRemote )
{
isRemote = ETrue;
}
}
//#endif //__UPNP_FRAMEWORK_2_0_
return isRemote;
}
// -----------------------------------------------------------------------------
// CMPXAppUi::SetMediaL
// -----------------------------------------------------------------------------
//
void CMPXAppUi::SetMediaL( CMPXMedia& aMedia )
{
// Set to collection
CMPXCommand* cmd( CMPXCommand::NewL() );
CleanupStack::PushL( cmd );
cmd->SetTObjectValueL( KMPXCommandGeneralId, KMPXCommandIdCollectionSet );
cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue );
TUid colId( aMedia.ValueTObjectL<TUid>(KMPXMediaGeneralCollectionId));
cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, colId.iUid );
cmd->SetCObjectValueL<CMPXMedia>( KMPXCommandColSetMedia, &aMedia );
iCollectionUtility->Collection().CommandL( *cmd );
CleanupStack::PopAndDestroy( cmd );
}
// ---------------------------------------------------------------------------
// Handle Custom messages from the collection
// ---------------------------------------------------------------------------
//
void CMPXAppUi::HandleCollectionMessage( CMPXMessage* aMessage, TInt aError )
{
if ( aError == KErrNone && aMessage )
{
TRAP_IGNORE( DoHandleCollectionMessageL( *aMessage ) )
}
}
// ---------------------------------------------------------------------------
// From MMPXCollectionObserver.
// Handles the collection entries being opened.
// ---------------------------------------------------------------------------
//
void CMPXAppUi::HandleOpenL(
const CMPXMedia& /* aEntries */,
TInt /* aIndex */,
TBool /* aComplete */,
TInt aError )
{
if ( aError != KErrNone )
{
// Clip the collection path to root level and reopen
// This could happen after a USB refresh event where the
// item no longer exists
//
CMPXCollectionPath* path = iCollectionUtility->Collection().PathL();
CleanupStack::PushL( path );
while( path->Levels() > 1)
{
path->Back();
}
iCollectionUtility->Collection().OpenL( *path );
CleanupStack::PopAndDestroy( path );
}
}
// ---------------------------------------------------------------------------
// From MMPXCollectionObserver.
// Handles the item being opened.
// ---------------------------------------------------------------------------
//
void CMPXAppUi::HandleOpenL(
const CMPXCollectionPlaylist& aPlaylist,
TInt aError )
{
MPX_FUNC("CMPXAppUi::HandleOpenL()");
if ( KErrNone == aError )
{
if( !IsEmbedded() )
{
TInt count ( aPlaylist.Count() ) ;
// temporarily disable repeat and shuffle if playlist
// is a podcast playlist and the list is not empty.
if(KMPXUidPodcastDBPlugin == TUid::Uid((TInt)aPlaylist.Path().Id(0)))
{
if(count > 0)
{
CMPXCollectionPlaylist* tmpPlaylist =
CMPXCollectionPlaylist::NewL( aPlaylist );
CleanupStack::PushL( tmpPlaylist );
tmpPlaylist->SetRepeatEnabled( EFalse );
tmpPlaylist->SetShuffleEnabledL( EFalse );
iPlaybackUtility->InitL( *tmpPlaylist, ETrue );
CleanupStack::PopAndDestroy( tmpPlaylist );
}
else
{
// Empty now playing
//
CMPXCollectionPlaylist* tmpPlaylist =
CMPXCollectionPlaylist::NewL( aPlaylist );
CleanupStack::PushL( tmpPlaylist );
tmpPlaylist->SetRepeatEnabled( EFalse );
tmpPlaylist->SetShuffleEnabledL( EFalse );
iPlaybackUtility->InitL( *tmpPlaylist, ETrue );
RArray<TUid> array;
CleanupClosePushL( array );
CMPXCollectionPath* pbPath =
CMPXCollectionPath::NewL( tmpPlaylist->Path() );
CleanupStack::PushL( pbPath );
if ( pbPath->Levels() > 0 )
{
array.AppendL( TUid::Uid( pbPath->Id( 0 ) ) );
}
CleanupStack::PopAndDestroy( pbPath );
array.AppendL( KLocalPlaybackUid );
if ( IsEmbedded() )
{
array.AppendL( TUid::Uid( KMPXPluginTypeEmbeddedPlaybackUid ));
}
else
{
array.AppendL( TUid::Uid( KMPXPluginTypePlaybackUid ) );
}
iViewUtility->ActivateViewL( array );
CleanupStack::PopAndDestroy( &array );
CleanupStack::PopAndDestroy( tmpPlaylist );
}
}
else
{
#ifdef RD_BROWSER_PROGRESSIVE_DOWNLOAD
if ( iPdParameterHandler && !iPdParameterHandler->IsPlaybackCompleted())
{
iPdParameterHandler->HandleCommandL(EPbCmdPause);
}
#endif // RD_BROWSER_PROGRESSIVE_DOWNLOAD
if ( count > 0 )
{
iPlaybackUtility->InitL( aPlaylist, ETrue );
}
else if( count == 0 &&
iPathRestore->Initialized() )
{
// Empty now playing
//
iPlaybackUtility->InitL( aPlaylist, EFalse );
RArray<TUid> array;
CleanupClosePushL( array );
CMPXCollectionPath* pbPath =
CMPXCollectionPath::NewL( aPlaylist.Path() );
CleanupStack::PushL( pbPath );
if ( pbPath->Levels() > 0 )
{
array.AppendL( TUid::Uid( pbPath->Id( 0 ) ) );
}
CleanupStack::PopAndDestroy( pbPath );
if ( IsEmbedded() )
{
array.AppendL( TUid::Uid( KMPXPluginTypeEmbeddedPlaybackUid ));
}
else
{
array.AppendL( TUid::Uid( KMPXPluginTypePlaybackUid ) );
}
iViewUtility->ActivateViewL( array );
CleanupStack::PopAndDestroy( &array );
}
}
// ETrue->initialize next song concurrently
}
else
{
// aPlaylist is const, must copy
//
CMPXCollectionPlaylist* tmp =
CMPXCollectionPlaylist::NewL( aPlaylist );
CleanupStack::PushL( tmp );
tmp->SetEmbeddedPlaylist( ETrue );
tmp->SetRepeatEnabled( EFalse );
tmp->SetShuffleEnabledL( EFalse );
iPlaybackUtility->InitL( *tmp, ETrue );
CleanupStack::PopAndDestroy( tmp );
}
}
}
// ---------------------------------------------------------------------------
// From MMPXCHelperEmbeddedOpenObserver
// Handles OpenL from that occured in embedded mode
// ---------------------------------------------------------------------------
//
void CMPXAppUi::HandleEmbeddedOpenL( TInt aErr, TMPXGeneralCategory aCategory )
{
MPX_FUNC( "CMPXAppUi::HandleEmbeddedOpenL" );
if( aErr != KErrNone )
{
iCommonUiHelper->HandleErrorL( aErr );
// Kill MPX
RunAppShutter();
}
else // No error, set the launch mode
{
iPlaybackUtility->CommandL( EPbCmdDisableEffect );
if( aCategory == EMPXPlaylist )
{
if ( MPXTlsHelper::LaunchMode() == EMPXLaunchModePlaying )
{
iLaunchModePlaying = ETrue;
}
MPXTlsHelper::SetLaunchModeL( EMPXLaunchModePlaylist );
}
else // ( aCategory == EMPXSong )
{
MPXTlsHelper::SetLaunchModeL( EMPXLaunchModeTrack );
iViewUtility->ActivateViewL( TUid::Uid( KMPXPluginTypeEmbeddedPlaybackUid ));
}
}
}
// ---------------------------------------------------------------------------
// From MMPXViewActivationObserver.
// Handle view activation.
// ---------------------------------------------------------------------------
//
void CMPXAppUi::HandleViewActivation(
const TUid& aCurrentViewType,
const TUid& aPreviousViewType )
{
MPX_FUNC( "CMPXAppUi::HandleViewActivation" );
MPX_DEBUG3("CurrentViewType=0x%x, PreviousViewType=0x%x", aCurrentViewType.iUid, aPreviousViewType.iUid);
iCurrentViewType = aCurrentViewType;
iPreviousViewType = aPreviousViewType;
iDeferredViewActivationUid.Reset();
switch ( aCurrentViewType.iUid )
{
case KMPXPluginTypePlaybackUid:
{
if ( IsForeground() )
{
iMediaKeyHandler->DismissNotifier( EDisplayMediaPopup );
}
break;
}
case KMPXPluginTypeCollectionUid:
{
if (iRefreshCollectionView )
{
iRefreshCollectionView = EFalse;
TRAP_IGNORE(ReOpenPathL());
}
break;
}
default:
{
// Do nothing
break;
}
}
}
// ---------------------------------------------------------------------------
// From CEikAppUi.
// Opens the specified file
// ---------------------------------------------------------------------------
//
void CMPXAppUi::HandleViewUpdate(
TUid /* aViewUid */,
MMPXViewActivationObserver::TViewUpdateEvent /* aUpdateEvent */,
TBool /* aLoaded */,
TInt /* aData */)
{
MPX_FUNC( "CMPXAppUi::HandleViewUpdate" );
}
// ---------------------------------------------------------------------------
// From CEikAppUi.
// Opens the specified file
// ---------------------------------------------------------------------------
//
void CMPXAppUi::OpenFileL( const TDesC& aFileName )
{
MPX_FUNC( "CMPXAppUi::OpenFileL" );
#ifdef RD_BROWSER_PROGRESSIVE_DOWNLOAD
if ( iPdParameterHandler )
{
// no need to open file at this time.
return;
}
#endif //RD_BROWSER_PROGRESSIVE_DOWNLOAD
if ( IsEmbedded() )
{
CreateMemberVariablesL();
iViewUtility->PreLoadViewL( TUid::Uid( KMPXPluginTypeEmbeddedPlaybackUid ));
// Open file with collection helper
iCollectionUiHelper->OpenL( MPXTlsHelper::HostUid(),
aFileName, this,
EMPXCollectionPluginMusic );
}
else
{
MPX_DEBUG1( "CMPXAppUi::OpenFileL Standalone" );
TDataType datatype( TUid::Uid( KMusicPlayerAppUidConstant ) );
iDocHandler->OpenTempFileL( aFileName, iFile );
CAiwGenericParamList* paramList = CAiwGenericParamList::NewLC();
TMPXLaunchMode mode( EMPXLaunchModeStopped );
TAiwVariant value( mode );
TAiwGenericParam param( EGenericParamPlayerInitMode, value );
paramList->AppendL( param ); // Takes ownership
TRAPD( err, iDocHandler->OpenFileEmbeddedL( iFile, datatype, *paramList ));
//
// ignore some document handler errors
//
if ( err == KErrServerTerminated )
{
//
// Document handler leaves with -15 if end key is pressed when
// embedded application is not fully started or embedded
// application panics in start up. So we can only close the
// App in this point and hope that user is press end key
//
HandleCommandL( EEikCmdExit );
}
else if ( err != KErrNone )
{
// Reset error since it was handled here and
// the program will exit
//
User::Leave( err );
}
CleanupStack::PopAndDestroy(paramList);
MPX_DEBUG1( "CMPXAppUi::OpenFileL Register as callback for exit" );
iDocHandler->SetExitObserver(this);
iStandAlone = ETrue;
}
}
// ---------------------------------------------------------------------------
// From CCoeAppUi.
// Handle foreground event.
// ---------------------------------------------------------------------------
//
void CMPXAppUi::HandleForegroundEventL(
TBool aForeground )
{
MPX_FUNC_EX( "CMPXAppUi::HandleForegroundEventL" );
if ( !aForeground )
{
// music player is going to background
// set key repeat rate to normal avkon rate
CEikonEnv::Static()->WsSession().SetKeyboardRepeatRate(
KAknKeyboardRepeatInitialDelay, KAknStandardKeyboardRepeatRate );
CEikonEnv::Static()->WsSession().Flush();
}
// Dismiss playback popup if foreground app is active idle or playback
// view is on foreground
if ( ( !aForeground && IsActiveIdleEnabled() && IsIdleAppForeground() )
|| ( aForeground
&& ( KMPXPluginTypePlaybackUid == iCurrentViewType.iUid ) ) )
{
iMediaKeyHandler->DismissNotifier( EDisplayMediaPopup );
}
if ( aForeground && iDeferredViewActivationUid.Count() != 0 )
{
MPX_DEBUG1( "CMPXAppUi::HandleForegroundEventL deferred view activation, activating" );
iViewUtility->ActivateViewL( iDeferredViewActivationUid );
iDeferredViewActivationUid.Reset();
}
CAknViewAppUi::HandleForegroundEventL( aForeground );
}
// ---------------------------------------------------------------------------
// From CEikAppUi.
// Owerwritten -> file opening
// (app startup via shell commands)
// ---------------------------------------------------------------------------
//
TBool CMPXAppUi::ProcessCommandParametersL(
TApaCommand /*aCommand*/,
TFileName& aDocumentName,
const TDesC8& /*aTail*/ )
{
MPX_FUNC_EX( "CMPXAppUi::ProcessCommandParametersL TApaCommand" );
return ConeUtils::FileExists( aDocumentName );
}
// ---------------------------------------------------------------------------
// Launch matrix menu suite with specific message
// ---------------------------------------------------------------------------
//
void CMPXAppUi::LaunchMmViewL( const TDesC8& aMessage )
{
TApaTaskList taskList( iCoeEnv->WsSession() );
TApaTask task = taskList.FindApp( TUid::Uid( KMmUid3 ) );
if ( task.Exists() )
{
task.SendMessage( TUid::Uid( KUidApaMessageSwitchOpenFileValue ),
aMessage );
}
}
// ---------------------------------------------------------------------------
// From CEikAppUi.
// Handle commands.
// ---------------------------------------------------------------------------
//
void CMPXAppUi::HandleCommandL(
TInt aCommand )
{
MPX_FUNC( "CMPXAppUi::HandleCommandL" );
TMPXPlaybackCommand cmd = EPbCmdEnd;
switch ( aCommand )
{
case EMPXCmdCheckIADUpdates:
{
TRAP_IGNORE( CheckUpdatesL() );
break;
}
case EMPXCmdPlay:
case EMPXCmdPause:
case EMPXCmdPlayPause:
case EMPXCmdStop:
case EMPXCmdNext:
case EMPXCmdPrevious:
case EMPXCmdSeekForward:
case EMPXCmdSeekBackward:
case EMPXCmdStopSeeking:
{
switch ( aCommand )
{
case EMPXCmdPlay:
cmd = EPbCmdPlay;
break;
case EMPXCmdPause:
cmd = EPbCmdPause;
break;
case EMPXCmdPlayPause:
cmd = EPbCmdPlayPause;
break;
case EMPXCmdStop:
cmd = EPbCmdStop;
break;
case EMPXCmdNext:
cmd = EPbCmdNext;
break;
case EMPXCmdPrevious:
cmd = EPbCmdPrevious;
break;
case EMPXCmdSeekForward:
cmd = EPbCmdStartSeekForward;
break;
case EMPXCmdSeekBackward:
cmd = EPbCmdStartSeekBackward;
break;
case EMPXCmdStopSeeking:
cmd = EPbCmdStopSeeking;
break;
default:
break;
}
DoHandleMediaKeyCommandL( cmd );
break;
}
case EMPXCmdGoToNowPlaying:
{
#ifdef RD_BROWSER_PROGRESSIVE_DOWNLOAD
TBool pdPlaybackCompleted(EFalse);
if ( iPdParameterHandler )
{
pdPlaybackCompleted = iPdParameterHandler->IsPlaybackCompleted();
if ( pdPlaybackCompleted )
{
delete iPdParameterHandler;
iPdParameterHandler = NULL;
}
}
MMPXPlaybackUtility* activePlaybackUtility = MMPXPlaybackUtility::UtilityL( KPbModeActivePlayer );
MMPXPlayer* player =
activePlaybackUtility->PlayerManager().CurrentPlayer();
TUid pluginUid( KNullUid );
RArray<TUid> array;
CleanupClosePushL( array );
MMPXSource* source = activePlaybackUtility->Source();
CMPXCollectionPlaylist* pl = NULL;
if( source )
{
pl = source->PlaylistL();
}
if ( pl || !pdPlaybackCompleted )
{
if (pl)
delete pl;
if ( player )
{
array.AppendL( player->UidL() );
if ( IsEmbedded() )
{
array.AppendL( TUid::Uid( KMPXPluginTypeEmbeddedPlaybackUid ) );
}
}
else
{
if ( IsEmbedded() )
{
array.AppendL( TUid::Uid( KMPXPluginTypeEmbeddedPlaybackUid ) );
}
else
{
array.AppendL( TUid::Uid( KMPXPluginTypePlaybackUid ) );
}
}
// add the collection plugin UID to ensure the correct
// last playback view is activated
//MMPXSource* source = activePlaybackUtility->Source();
if( source )
{
CMPXCollectionPlaylist* pl = source->PlaylistL();
if (pl)
{
CleanupStack::PushL( pl );
const CMPXCollectionPath& path = pl->Path();
if(path.Levels() > 0)
{
array.AppendL(TUid::Uid(path.Id(0)));
}
CleanupStack::PopAndDestroy( pl );
}
}
else if ( !iPathRestore->Initialized() )
{
if ( iPathRestore->RooPathId() != KNullUid )
{
array.AppendL( iPathRestore->RooPathId() );
}
}
}
else
{
CMPXCollectionPath* cPath = iCollectionUtility->Collection().PathL();
CleanupStack::PushL( cPath );
array.AppendL( TUid::Uid( KMPXPluginTypeCollectionUid ) );
if ( cPath->Levels() > 0 )
{
array.AppendL( TUid::Uid( cPath->Id( 0 ) ) );
}
CleanupStack::PopAndDestroy( cPath );
}
if ( iAppStartedByBrowser && !icollectionBrowsed && pdPlaybackCompleted)
{
activePlaybackUtility->Close();
CleanupStack::PopAndDestroy( &array );
RunAppShutter();
break;
}
else
{
activePlaybackUtility->Close();
iViewUtility->ActivateViewL( array );
CleanupStack::PopAndDestroy( &array );
}
break;
}
#else // RD_BROWSER_PROGRESSIVE_DOWNLOAD not supported
MMPXPlayer* player =
iPlaybackUtility->PlayerManager().CurrentPlayer();
TUid pluginUid( KNullUid );
RArray<TUid> array;
CleanupClosePushL( array );
if ( player )
{
array.AppendL( player->UidL() );
if ( IsEmbedded() )
{
array.AppendL( TUid::Uid( KMPXPluginTypeEmbeddedPlaybackUid ) );
}
}
else
{
if ( IsEmbedded() )
{
array.AppendL( TUid::Uid( KMPXPluginTypeEmbeddedPlaybackUid ) );
}
else
{
array.AppendL( TUid::Uid( KMPXPluginTypePlaybackUid ) );
}
}
// add the collection plugin UID to ensure the correct
// last playback view is activated
MMPXSource* source = iPlaybackUtility->Source();
if( source )
{
CMPXCollectionPlaylist* pl = source->PlaylistL();
if (pl)
{
CleanupStack::PushL( pl );
const CMPXCollectionPath& path = pl->Path();
if(path.Levels() > 0)
{
array.AppendL(TUid::Uid(path.Id(0)));
}
CleanupStack::PopAndDestroy( pl );
}
}
iViewUtility->ActivateViewL( array );
CleanupStack::PopAndDestroy( &array );
break;
}
#endif // RD_BROWSER_PROGRESSIVE_DOWNLOAD
case EMPXCmdVolumeChanged:
cmd = EPbCmdSetVolume;
HandlePopupL(cmd);
break;
case EMPXCmdIgnoreExternalCommand:
{
iIgnoreExternalCommand = ETrue;
break;
}
case EMPXCmdHandleExternalCommand:
{
iIgnoreExternalCommand = EFalse;
break;
}
case EMPXCmdHideApp:
{
// Move Music Player to background
// magic: -1 = force wg to background
iEikonEnv->RootWin().SetOrdinalPosition( -1 );
break;
}
case EAknSoftkeyBack:
{
#ifdef RD_BROWSER_PROGRESSIVE_DOWNLOAD
if ( iViewUtility->ViewHistoryDepth() == 1 || iAppStartedByBrowser )
{
HandleCommandL( EEikCmdExit );
}
else if ( iPbvStartedByBrowser && !iAppStartedByBrowser )
{
iPbvStartedByBrowser = EFalse;
if( iPdParameterHandler )
{
if( !( iPdParameterHandler->IsPlaybackCompleted() ) )
{
iPdParameterHandler->HandleCommandL( EPbCmdStop );
}
iPdParameterHandler->HandleCommandL( EPbCmdClose );
delete iPdParameterHandler;
iPdParameterHandler = NULL;
}
iRefreshCollectionView = ETrue;
iViewUtility->ActivatePreviousViewL();
BringUpBrowserL();
}
else if ( !iPdParameterHandler || !iAppStartedByBrowser )
{
iViewUtility->ActivatePreviousViewL();
}
else
{
HandleCommandL( EEikCmdExit );
}
#else
// if we're in top level of our local view stack,
// back command exits the app. otherwise activate
// the previous view in our local view stack
if ( iViewUtility->ViewHistoryDepth() == 1 )
{
HandleCommandL( EEikCmdExit );
}
else
{
iViewUtility->ActivatePreviousViewL();
}
#endif // RD_BROWSER_PROGRESSIVE_DOWNLOAD
break;
}
case EEikCmdExit: // fall through
case EAknCmdExit:
case EAknSoftkeyExit:
{
if ( iView && KMPXPluginTypeCollectionUid == iCurrentViewType.iUid )
{
MPX_DEBUG2( "CMPXAppUi::HandleCommand() "
"sending EMPXCmdCancelReorder to view %d",
KMPXPluginTypeCollectionUid );
iView->HandleCommandL( EMPXCmdCancelReorder );
}
CloseWaitNoteL();
if( aCommand == EAknCmdExit || aCommand == EEikCmdExit )
{
TKeyEvent key;
key.iCode = EKeyEscape;
key.iModifiers = 0;
// Under EQ it is possible to have multiple dialogs open
TInt err( KErrNone );
while( IsDisplayingDialog() && err == KErrNone )
{
TRAP( err, iCoeEnv->SimulateKeyEventL(key,EEventKey); )
}
}
TBool needToExit( EFalse );
if ( iSaveMode != EMPXSaveModeIdle )
{
iCancelFileMan = ETrue;
}
else
{
if( iPathRestore )
{
TRAP_IGNORE(iPathRestore->SavePathL());
}
if ( iPlaybackUtility )
{
MMPXPlayerManager& manager = iPlaybackUtility->PlayerManager();
TRAP_IGNORE( manager.ClearSelectPlayersL() );
iPlaybackUtility->CommandL( EPbCmdClose );
}
needToExit = ETrue;
}
if( needToExit )
{
Exit();
}
break;
}
case EAknCmdHelp:
{
HlpLauncher::LaunchHelpApplicationL(
iEikonEnv->WsSession(),
AppHelpContextL() );
break;
}
case EMPXCmdSaveAndReopen:
{
iCancelFileMan = EFalse;
iSaveMode = EMPXOpenAfterSave;
MPX_TRAPD( err, DoSaveL());
if ( KErrNone != err )
{
HandleSaveComplete( err );
}
break;
}
case EMPXCmdIsFileSaved:
{
TFileName SavedAudioFile;
CreateAutomaticSavePathL( SavedAudioFile );
break;
}
case EMPXCmdSaveForUseAsContact:
case EMPXCmdSaveForUseAsRingtone:
{
iCancelFileMan = EFalse;
ASSERT( iFile.SubSessionHandle() );
TBool abort = EFalse;
TBool aiwExecuted = EFalse;
TFileName fullName;
iFile.FullName( fullName );
TParsePtrC fileParse( fullName );
TBool isPrivate = (fileParse.NamePresent() &&
!KMPXMusicplayerPrivateFolder().CompareF(
fileParse.Path().Left(
KMPXMusicplayerPrivateFolder().Length())));
TFileName savedFile;
CreateAutomaticSavePathL( savedFile );
if ( isPrivate && !ConeUtils::FileExists( savedFile ) )
{
HBufC* string( StringLoader::LoadLC( R_MPX_QUERY_CONF_SAVE_DOWNLOADED,
fileParse.Name() ));
CAknQueryDialog* confirmationDlg( CAknQueryDialog::NewL(
CAknQueryDialog::EConfirmationTone ));
if ( confirmationDlg->ExecuteLD( R_MPX_SAVE_SONG_CONFIRMATION_QUERY,
*string ))
{
// User wants to save the file and execute AIW function
if ( aCommand == EMPXCmdSaveForUseAsRingtone )
{
iSaveMode = EMPXAssignRingtone;
}
else if ( aCommand == EMPXCmdSaveForUseAsContact )
{
iSaveMode = EMPXAssignContact;
}
MPX_TRAPD( err, DoSaveL() );
if ( KErrNone != err )
{
HandleSaveComplete( err );
}
abort = EFalse;
aiwExecuted = ETrue;
if ( iView )
{
iView->HandleCommandL( EMPXCmdSaveComplete );
}
}
else
{
if ( iView )
{
iView->HandleCommandL( EMPXCmdSaveNotProgress );
}
abort = ETrue;
}
CleanupStack::PopAndDestroy( string );
}
else if ( ConeUtils::FileExists( savedFile ) )
{
if ( iView )
{
iView->HandleCommandL( EMPXCmdSaveNotProgress );
}
MPXTlsHelper::SetFilePath( savedFile );
}
if ( !abort && !aiwExecuted && iView )
{
if ( aCommand == EMPXCmdSaveForUseAsRingtone )
{
TRAP_IGNORE(
iView->HandleCommandL( EMPXCmdAfterSaveAiwCmdAssign ));
}
else if ( aCommand == EMPXCmdSaveForUseAsContact )
{
TRAP_IGNORE(
iView->HandleCommandL( EMPXCmdAfterSaveUseAsCascade ));
}
}
break;
}
case EMPXCmdSaveAndExit: // fall though
case EMPXCmdSaveAndExitHostApp:
{
iCancelFileMan = EFalse;
ASSERT( iFile.SubSessionHandle() );
TFileName fullName;
iFile.FullName( fullName );
TParsePtrC fileParse( fullName );
HBufC* string( StringLoader::LoadLC( R_MPX_QUERY_CONF_SAVE_DOWNLOADED,
fileParse.Name() ));
CAknQueryDialog* confirmationDlg( CAknQueryDialog::NewL(
CAknQueryDialog::EConfirmationTone ));
//#ifdef __COVER_DISPLAY
confirmationDlg->PublishDialogL(
EMPlayerQueryNotSaved,
KMPlayerNoteCategory);
CAknMediatorFacade* covercl(
AknMediatorFacade( confirmationDlg ) );
if ( covercl )
{
covercl->BufStream() << fileParse.Name();
}
//#endif //__COVER_DISPLAY
if ( confirmationDlg->ExecuteLD( R_MPX_SAVE_SONG_CONFIRMATION_QUERY,
*string ))
{
iSaveMode = ( aCommand == EMPXCmdSaveAndExit ?
EMPXExitAppAfterSave : EMPXExitHostAppAfterSave );
MPX_TRAPD( err, DoSaveL() );
if ( KErrNone != err )
{
HandleSaveComplete( err );
}
}
else
{
if ( aCommand == EMPXCmdSaveAndExit )
{
RunAppShutter();
}
else
{
// EMPXCmdSaveAndExitHostApp
CAknEnv::RunAppShutter();
}
}
CleanupStack::PopAndDestroy( string );
break;
}
case EAknCmdTaskSwapper:
{
// Handle command when Music Player is selected in Multitasker
// and Music Player is the foreground app.
break;
}
case EMPXCmdGotoCollection:
{
#ifdef RD_BROWSER_PROGRESSIVE_DOWNLOAD
iPdPbvStartedByBrowser = EFalse;
icollectionBrowsed = ETrue;
#endif // RD_BROWSER_PROGRESSIVE_DOWNLOAD
iStandAlone = EFalse;
break;
}
default:
{
// do nothing if the command is not reconized
MPX_DEBUG2( "CMPXAppUi::HandleCommandL unknown command 0x%x", aCommand );
break;
}
}
}
// ---------------------------------------------------------------------------
// From CEikAppUi.
// Handle window server events.
// ---------------------------------------------------------------------------
//
void CMPXAppUi::HandleWsEventL(
const TWsEvent& aEvent,
CCoeControl* aDestination )
{
MPX_FUNC_EX( "CMPXAppUi::HandleWsEventL" );
if ( aEvent.Type() == KAknUidValueEndKeyCloseEvent )
{
TMPXPlaybackState playerState( EPbStateNotInitialised );
if( iPlaybackUtility )
{
TRAP_IGNORE( playerState = iPlaybackUtility->StateL() );
}
if ( ( iCommonUiHelper->ExitOptionHiddenL() && !IsEmbedded() ) ||
EPbStatePlaying == playerState ||
EPbStatePaused == playerState )
{
// Go back to Idle when End key is pressed in non-embedded mode or
// player is in playing/paused mode
if( IsForeground() )
{
ActivatePhoneAppL();
}
return;
}
}
// Notify the playback popup that orientation is about to change
if( iMediaKeyHandler && aEvent.Type() == EEventScreenDeviceChanged )
{
iMediaKeyHandler->NotifyOrientationChangeBegin();
}
CAknAppUi::HandleWsEventL( aEvent, aDestination );
}
// ---------------------------------------------------------------------------
// From MCoeMessageObserver.
// Handle messages from windows server.
// ---------------------------------------------------------------------------
//
MCoeMessageObserver::TMessageResponse CMPXAppUi::HandleMessageL(
TUint32 aClientHandleOfTargetWindowGroup,
TUid aMessageUid,
const TDesC8& aMessageParameters )
{
MPX_FUNC_EX( "CMPXAppUi::HandleMessageL" );
MCoeMessageObserver::TMessageResponse ret( EMessageNotHandled );
if ( aMessageUid == KAppUidMusicPlayerX )
{
MPX_DEBUG2( "CMPXAppUi::HandleMessageL Message received for music player, size = %d", aMessageParameters.Size() );
// message for music player
HandleCommandParametersL( aMessageParameters );
ret = EMessageHandled;
}
#ifdef RD_BROWSER_PROGRESSIVE_DOWNLOAD
else if ( aMessageUid == KNullUid )
{
ASSERT(!IsEmbedded());////browser should not send messages to music player if it is not RootApp.
if ( aMessageParameters.Length() )
{
if ( IsBrowserClosed(aMessageParameters) )
{
if ( iAppStartedByBrowser )
{
RunAppShutter();
return EMessageHandled;
}
}
else
{
if (!iPdParameterHandler)
{
iPdParameterHandler = CMPXPdCommandHandler::NewL(iPlaybackUtility);
}
if(KErrNotFound == iPdParameterHandler->HandleCommandParametersL( aMessageParameters )) // File or dl id do not exist.
{
iCommonUiHelper->DisplayInfoNoteL(R_MPX_FILE_NOT_FOUND_TEXT);
HandleCommandL(EMPXCmdGoToNowPlaying);
BringUpBrowserL();
}
else
{
iPbvStartedByBrowser = ETrue;
}
ret = EMessageHandled;
}
}
}
#endif // RD_BROWSER_PROGRESSIVE_DOWNLOAD
else
{
ret = CAknViewAppUi::HandleMessageL(
aClientHandleOfTargetWindowGroup,
aMessageUid,
aMessageParameters );
}
return ret;
}
// -----------------------------------------------------------------------------
// From CEikAppUi.
// process message sent by another application
// -----------------------------------------------------------------------------
//
void CMPXAppUi::ProcessMessageL(
TUid aUid, const TDesC8& aParams )
{
MPX_FUNC_EX( "CMPXAppUi::ProcessMessageL" );
if ( aUid == KAppUidMusicPlayerX )
{
// message for music player
MPX_DEBUG2( "CMPXAppUi::ProcessMessageL Message received for music player, size = %d", aParams.Size() );
HandleCommandParametersL( aParams );
}
}
// -----------------------------------------------------------------------------
// From CEikAppUi.
// process command line parameter
// -----------------------------------------------------------------------------
//
TBool CMPXAppUi::ProcessCommandParametersL( CApaCommandLine& aCommandLine )
{
MPX_FUNC_EX( "CMPXAppUi::ProcessCommandParametersL CApaCommandLine" );
#ifdef RD_BROWSER_PROGRESSIVE_DOWNLOAD
if (EApaCommandOpen == aCommandLine.Command())
{
TPtrC param = aCommandLine.DocumentName();
if ( param.Length() )
{
if (!ConeUtils::FileExists(param))
{
iAppStartedByBrowser = ETrue;
iPdPbvStartedByBrowser = ETrue;
// Convert param to 8-bit.
HBufC8* param8 = HBufC8::NewLC( param.Length() );
param8->Des().Copy( param );
if ( IsBrowserClosed(*param8) )
{
Exit();
}
else
{
if (!iPdParameterHandler)
{
iPdParameterHandler = CMPXPdCommandHandler::NewL(iPlaybackUtility);//this is where it is created the first time
}
if ( KErrNotFound == iPdParameterHandler->HandleCommandParametersL( *param8 ) )
{
delete iPdParameterHandler;
iPdParameterHandler = NULL;
iCommonUiHelper->DisplayInfoNoteL(R_MPX_FILE_NOT_FOUND_TEXT);
BringUpBrowserL();
Exit();
}
else
{
// Default start up state for Progressive Download playback is Playing
MPXTlsHelper::SetLaunchModeL( EMPXLaunchModePlaying );
}
}
CleanupStack::PopAndDestroy( param8 );
}
}
}
#endif // RD_BROWSER_PROGRESSIVE_DOWNLOAD
const TPtrC8 command = aCommandLine.TailEnd();
if ( command.Size() > 0 )
{
HandleCommandParametersL( command );
}
return ETrue;
}
// ---------------------------------------------------------------------------
// From MMPXSaveHelperObserver
// Callback function to signal that saving a file is complete
// ---------------------------------------------------------------------------
//
void CMPXAppUi::HandleSaveComplete( TInt aErr )
{
MPX_DEBUG2("CMPXAppUi::HandleSaveComplete(%d) entering", aErr);
TRAP_IGNORE( DoHandleSaveCompleteL( aErr ) );
MPX_DEBUG1("CMPXAppUi::HandleSaveComplete() exiting" );
}
// ---------------------------------------------------------------------------
// From MMPXCollectionHelperObserver
// Callback function to signal that adding a file is complete
// ---------------------------------------------------------------------------
//
void CMPXAppUi::HandleAddFileCompleteL( TInt aErr )
{
MPX_DEBUG2("CMPXAppUi::HandleAddFileCompleteL(%d) entering", aErr);
iCommonUiHelper->DismissWaitNoteL();
// close collectionhelper since it is not needed now
if ( iCollectionHelper )
{
iCollectionHelper->Close();
iCollectionHelper = NULL;
}
if ( !aErr )
{
if (( iSaveMode != EMPXAssignRingtone ) &&
( iSaveMode != EMPXAssignContact ))
{
iCommonUiHelper->DisplayConfirmNoteL( R_MPX_SAVED_TO_COLLECTION_NOTE );
}
}
else if ( KErrNotSupported == aErr )
{
iCommonUiHelper->DisplayConfirmNoteL( R_MPX_SAVED_NOTE );
}
else if( iIsUsbOnGoing && (aErr != KErrNone) )
{
// Kill mpx embedded mode so usb can start
//
MPX_DEBUG1("CMPXAppUi::HandleAddFileCompleteL usb ongoing");
iSaveMode = EMPXExitAppAfterSave;
}
else
{
iCommonUiHelper->HandleErrorL( aErr );
}
if ( iView )
{
iView->HandleCommandL( EMPXCmdSaveComplete );
}
HandlePostSaveOperationL();
MPX_DEBUG1("CMPXAppUi::HandleAddFileCompleteL() exiting" );
}
// ---------------------------------------------------------------------------
// From MProgressDialogCallback.
// Get's called when a dialog is dismissed.
// ---------------------------------------------------------------------------
//
void CMPXAppUi::DialogDismissedL( TInt aButtonId )
{
MPX_DEBUG1("CMPXAppUi::DialogDismissedL");
// Cover UI start
//#ifdef __COVER_DISPLAY
if ( iCommandInitiator )
{
iCommandInitiator->CancelCommand( KMediatorSecondaryDisplayDomain,
KMPlayerNoteCategory,
EMPlayerNoteSaveOneItem );
}
//#endif
// Cover UI end
if ( aButtonId == EAknSoftkeyCancel && iView )
{
iView->HandleCommandL( EMPXCmdSaveCancelled );
if ( iSaveMode != EMPXSaveModeIdle )
{
iCancelFileMan = ETrue;
if( iSaveHelper )
{
iSaveHelper->Cancel();
}
iSaveMode = EMPXSaveModeIdle;
}
}
MPX_DEBUG1("CMPXAppUi::DialogDismissedL");
}
// -----------------------------------------------------------------------------
// CMPXAppUi::NotifyFileManOperation
// -----------------------------------------------------------------------------
//
MFileManObserver::TControl CMPXAppUi::NotifyFileManOperation()
{
MPX_DEBUG1("CMPXAppUi::NotifyFileManOperation(): entering");
// this code is run in CFileMan working thread.
if( iCancelFileMan )
{
MPX_DEBUG1("CMPXAppUi::NotifyFileManOperation(): ECancel");
return MFileManObserver::ECancel;
}
return MFileManObserver::EContinue;
}
// -----------------------------------------------------------------------------
// CMPXAppUi::DoUpdatePluginRefreshedTimeL
// -----------------------------------------------------------------------------
//
void CMPXAppUi::DoUpdatePluginRefreshedTimeL()
{
CMPXCommand* cmd = CMPXCommand::NewL();
CleanupStack::PushL( cmd );
cmd->SetTObjectValueL( KMPXCommandGeneralId, KMPXCommandIdUpdateRefreshTime );
cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue );
// Update Music
cmd->SetTObjectValueL<TUid>( KMPXCommandGeneralCollectionId, iMusicCollectionId );
iCollectionUtility->Collection().CommandL( *cmd );
// Update Podcast
if( !iDisablePodcasting )
{
cmd->SetTObjectValueL<TUid>( KMPXCommandGeneralCollectionId, iPodcastCollectionId );
iCollectionUtility->Collection().CommandL( *cmd );
}
CleanupStack::PopAndDestroy( cmd );
}
// -----------------------------------------------------------------------------
// CMPXAppUi::HandlePropertyL
// -----------------------------------------------------------------------------
//
void CMPXAppUi::HandlePropertyL(TMPXPlaybackProperty aProperty, TInt aValue, TInt aError)
{
if (aError == KErrNone)
{
switch (aProperty)
{
case EPbPropertyVolume:
{
iCurrentVolume = aValue;
}
break;
case EPbPropertyMaxVolume:
{
iMaxVolume = aValue;
}
break;
default:
break;
}
}
else
{
// How to handle error?
}
}
// -----------------------------------------------------------------------------
// CMPXAppUi::HandleSubPlayerNamesL
// -----------------------------------------------------------------------------
//
void CMPXAppUi::HandleSubPlayerNamesL(
TUid /*aPlayer*/,
const MDesCArray* /*aSubPlayers*/,
TBool /*aComplete*/,
TInt /*aError*/)
{
}
// -----------------------------------------------------------------------------
// CMPXAppUi::HandleMediaL
// -----------------------------------------------------------------------------
//
void CMPXAppUi::HandleMediaL(
const CMPXMedia& /*aProperties*/,
TInt /*aError*/)
{
}
// -----------------------------------------------------------------------------
// CMPXAppUi::IsActiveView
// -----------------------------------------------------------------------------
//
TBool CMPXAppUi::IsActiveView(TInt aViewType )
{
return (iCurrentViewType.iUid == aViewType ) || ((iCurrentViewType.iUid == KMPXPluginTypeWaitNoteDialogUid ) && (iPreviousViewType.iUid == aViewType));
}
// -----------------------------------------------------------------------------
// CMPXAppUi::ReOpenPathL
// -----------------------------------------------------------------------------
//
void CMPXAppUi::ReOpenPathL()
{
CMPXCollectionPath* path = iCollectionUtility->Collection().PathL ( );
CleanupStack::PushL ( path );
if ( path->Levels ( )> 1 )
{
path->Back ( );
iCollectionUtility->Collection().OpenL ( *path );
}
CleanupStack::PopAndDestroy ( path );
}
// -----------------------------------------------------------------------------
// CMPXAppUi::HandleServerAppExit
// -----------------------------------------------------------------------------
//
void CMPXAppUi::HandleServerAppExit(TInt /*aReason*/)
{
RunAppShutter();
}
#ifdef RD_BROWSER_PROGRESSIVE_DOWNLOAD
// -----------------------------------------------------------------------------
// CMPXAppUi::IsBrowserClosed
// -----------------------------------------------------------------------------
//
TBool CMPXAppUi::IsBrowserClosed(
const TDesC8& aParams )
{
TBool ret(EFalse);
CBufFlat* paramBuf = CBufFlat::NewL( /*anExpandSize*/1 );
CleanupStack::PushL( paramBuf );
paramBuf->InsertL( 0, aParams );
RBufReadStream readStream( *paramBuf );
CAiwGenericParamList* genParList = CAiwGenericParamList::NewLC( readStream );
TInt index = 0;
const TAiwGenericParam* paramTerminate = genParList->FindFirst( index,
EGenericParamTerminate, EVariantTypeTInt32 );
TInt32 terminateID = 0;
if ( paramTerminate )
{
paramTerminate->Value().Get( terminateID );
}
if ( terminateID )
{
ret = ETrue;
}
CleanupStack::PopAndDestroy( genParList );
CleanupStack::PopAndDestroy( paramBuf );
return ret;
}
// ---------------------------------------------------------
// Bring Browser application to the foreground.
// ---------------------------------------------------------
//
TBool CMPXAppUi::BringUpBrowserL()
{
TBool browserFound(EFalse);
RWsSession& wsSession=iEikonEnv->WsSession();
CAknTaskList* taskList = CAknTaskList::NewL( wsSession );
TApaTask task = taskList->FindRootApp( TUid::Uid(KMPXBrowserUid) );
delete taskList;
if( task.Exists() )
{
task.BringToForeground();
browserFound = ETrue;
}
return browserFound;
}
#endif // RD_BROWSER_PROGRESSIVE_DOWNLOAD
// -----------------------------------------------------------------------------
// CMPXAppUi::SuppressCollectionView
// -----------------------------------------------------------------------------
//
TBool CMPXAppUi::SuppressCollectionView()
{
#ifdef RD_BROWSER_PROGRESSIVE_DOWNLOAD
return ( iPdPbvStartedByBrowser || iStandAlone );
#else
return ( iStandAlone );
#endif
}
// -----------------------------------------------------------------------------
// CMPXAppUi::SetVolume
// -----------------------------------------------------------------------------
//
void CMPXAppUi::SetVolume( const TInt aVolume )
{
CMPXCommand* cmd( CMPXCommand::NewL() );
CleanupStack::PushL( cmd );
cmd->SetTObjectValueL<TInt>( KMPXCommandGeneralId, KMPXCommandIdPlaybackGeneral );
cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );
cmd->SetTObjectValueL<TBool>( KMPXCommandPlaybackGeneralNoBuffer, ETrue );
cmd->SetTObjectValueL<TInt>( KMPXCommandPlaybackGeneralType, EPbCmdSetVolume );
cmd->SetTObjectValueL<TUint>( KMPXCommandPlaybackGeneralData, aVolume );
iPlaybackUtility->CommandL( *cmd );
CleanupStack::PopAndDestroy( cmd );
}
// -----------------------------------------------------------------------------
// CMPXAppUi::MuteVolume
// -----------------------------------------------------------------------------
//
void CMPXAppUi::MuteVolume()
{
CMPXCommand* cmd( CMPXCommand::NewL() );
CleanupStack::PushL( cmd );
cmd->SetTObjectValueL<TInt>( KMPXCommandGeneralId, KMPXCommandIdPlaybackGeneral );
cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );
cmd->SetTObjectValueL<TBool>( KMPXCommandPlaybackGeneralNoBuffer, ETrue );
cmd->SetTObjectValueL<TInt>( KMPXCommandPlaybackGeneralType, EPbCmdMuteVolume );
iPlaybackUtility->CommandL( *cmd );
CleanupStack::PopAndDestroy( cmd );
}
// -----------------------------------------------------------------------------
// CMPXAppUi::UnMuteVolume
// -----------------------------------------------------------------------------
//
void CMPXAppUi::UnMuteVolume()
{
CMPXCommand* cmd( CMPXCommand::NewL() );
CleanupStack::PushL( cmd );
cmd->SetTObjectValueL<TInt>( KMPXCommandGeneralId, KMPXCommandIdPlaybackGeneral );
cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );
cmd->SetTObjectValueL<TBool>( KMPXCommandPlaybackGeneralNoBuffer, ETrue );
cmd->SetTObjectValueL<TInt>( KMPXCommandPlaybackGeneralType, EPbCmdUnMuteVolume );
iPlaybackUtility->CommandL( *cmd );
CleanupStack::PopAndDestroy( cmd );
}
// -----------------------------------------------------------------------------
// CMPXAppUi::UnMuteVolume
// -----------------------------------------------------------------------------
//
TInt CMPXAppUi::MPXCmdForPbCmd(
TMPXPlaybackCommand aCommand )
{
TInt cmd( KErrNotFound );
switch ( aCommand )
{
case EPbCmdStop:
{
cmd = EMPXCmdStop;
break;
}
case EPbCmdPlay:
{
cmd = EMPXCmdPlay;
break;
}
case EPbCmdPause:
{
cmd = EMPXCmdPause;
break;
}
case EPbCmdPlayPause:
{
cmd = EMPXCmdPlayPause;
break;
}
case EPbCmdNext:
{
cmd = EMPXCmdNext;
break;
}
case EPbCmdPrevious:
{
cmd = EMPXCmdPrevious;
break;
}
case EPbCmdStartSeekForward:
{
cmd = EMPXCmdSeekForward;
break;
}
case EPbCmdStartSeekBackward:
{
cmd = EMPXCmdSeekBackward;
break;
}
case EPbCmdStopSeeking:
{
cmd = EMPXCmdStopSeeking;
break;
}
default:
{
// Command not found
break;
}
}
return cmd;
}
// -----------------------------------------------------------------------------
// CMPXAppUi::CheckAvailableMemory
// -----------------------------------------------------------------------------
//
void CMPXAppUi::CheckAvailableMemory( TInt aNeedMemory )
{
TMemoryInfoV1Buf info;
UserHal::MemoryInfo(info);
if( info().iFreeRamInBytes < aNeedMemory )
{
HBufC* title =
StringLoader::LoadLC( R_MPX_NO_MEMORY_INFO );
CAknGlobalNote* infoNote = CAknGlobalNote::NewLC();
infoNote->ShowNoteL(
EAknGlobalInformationNote,
title->Des() );
CleanupStack::PopAndDestroy( infoNote );
CleanupStack::PopAndDestroy( title );
Exit();
return;
}
}
// -----------------------------------------------------------------------------
// CMPXAppUi::CheckUpdatesComplete
// from base class MIAUpdateObserver
// -----------------------------------------------------------------------------
//
void CMPXAppUi::CheckUpdatesComplete( TInt aErrorCode, TInt aAvailableUpdates )
{
MPX_DEBUG2("CMPXAppUi::CheckUpdatesComplete(UpdatesComplete: %d) entering", aErrorCode);
if ( aErrorCode == KErrNone )
{
MPX_DEBUG2("CMPXAppUi::CheckUpdatesComplete(AvailableUpdates: %d)", aAvailableUpdates);
if ( aAvailableUpdates > 0 )
{
// There were some updates available. Let's ask if the user wants to update them.
iUpdate->UpdateQuery();
}
else
{
// No updates available. CIAUpdate object could be deleted
CleanUpdateParams();
}
}
MPX_DEBUG1( "CMPXAppUi::CheckUpdatesComplete() exiting" );
}
// -----------------------------------------------------------------------------
// CMPXAppUi::UpdateComplete
// from base class MIAUpdateObserver
// -----------------------------------------------------------------------------
//
void CMPXAppUi::UpdateComplete( TInt /*aErrorCode*/, CIAUpdateResult* aResultDetails )
{
MPX_DEBUG1( "CMPXAppUi::UpdateComplete() entering" );
// The update process that the user started from IAUpdate UI is now completed.
if(aResultDetails)
{
delete aResultDetails; // Ownership was transferred, so this must be deleted by the client
aResultDetails = NULL;
}
// We do not need the client-server session anymore, let's delete the object to close the session
CleanUpdateParams();
MPX_DEBUG1( "CMPXAppUi::UpdateComplete() exiting" );
}
// -----------------------------------------------------------------------------
// CMPXAppUi::UpdateQueryComplete
// from base class MIAUpdateObserver
// -----------------------------------------------------------------------------
//
void CMPXAppUi::UpdateQueryComplete( TInt aErrorCode, TBool aUpdateNow )
{
MPX_DEBUG2("CMPXAppUi::UpdateQueryComplete(QueryComplete: %d) entering", aErrorCode);
if ( aErrorCode == KErrNone )
{
MPX_DEBUG2("CMPXAppUi::UpdateQueryComplete(UpdateNow: %d) ", aUpdateNow);
if ( aUpdateNow )
{
// User choosed to update now, so let's launch the IAUpdate UI.
iUpdate->ShowUpdates( *iParameters );
}
else
{
// The answer was 'Later'. CIAUpdate object could be deleted
CleanUpdateParams();
}
}
MPX_DEBUG1( "CMPXAppUi::UpdateQueryComplete() exiting" );
}
// -----------------------------------------------------------------------------
// CMPXAppUi::UpdateQueryComplete
// -----------------------------------------------------------------------------
//
void CMPXAppUi::CleanUpdateParams()
{
MPX_DEBUG1( "CMPXAppUi::CleanUpdateParams() entering" );
if(iUpdate)
{
delete iUpdate;
iUpdate = NULL;
}
if(iParameters)
{
delete iParameters;
iParameters = NULL;
}
MPX_DEBUG1( "CMPXAppUi::CleanUpdateParams() exiting" );
}
// -----------------------------------------------------------------------------
// CMPXAppUi::CheckUpdatesL
// -----------------------------------------------------------------------------
//
void CMPXAppUi::CheckUpdatesL()
{
MPX_DEBUG1( "CMPXAppUi::CheckUpdatesL() entering" );
if ( FeatureManager::FeatureSupported( KFeatureIdIAUpdate ) )
{
MPX_DEBUG1( "CMPXAppUi::CheckUpdatesL() IAD Update supported" );
TRAP_IGNORE( iUpdate = CIAUpdate::NewL( *this ) );
MPX_DEBUG1( "CMPXAppUi::CheckUpdatesL() IAD Update Client Created" );
if ( iUpdate )
{
MPX_DEBUG1( "CMPXAppUi::CheckUpdatesL() creating IAD Update paramentes" );
iParameters = CIAUpdateParameters::NewL();
// Search for updates using SIS package UID
iParameters->SetUid( TUid::Uid( KMPXMusicPlayerSISPkgUid ) );
//mpx.exe to be started after update is finished
iParameters->SetCommandLineExecutableL( KMPXMusicPlayerExec );
//check the updates
iUpdate->CheckUpdates( *iParameters );
}
}
MPX_DEBUG1( "CMPXAppUi::CheckUpdatesL() exiting" );
}
#ifdef FF_OOM_MONITOR2_COMPONENT
// -----------------------------------------------------------------------------
// CMPXAppUi::SetMpxOomPriorityL
// -----------------------------------------------------------------------------
//
void CMPXAppUi::SetMpxOomPriorityL( ROomMonitorSession::TOomPriority aPriority )
{
if( aPriority != iOomPriority )
{
ROomMonitorSession monitorSession;
User::LeaveIfError ( monitorSession.Connect() );
// No leaving code after this point, so no need to use cleanup stack
monitorSession.SetOomPriority( aPriority );
iOomPriority = aPriority;
monitorSession.Close(); // CLOSE THE OOM SESSION....
}
}
// -----------------------------------------------------------------------------
// CMPXAppUi::CheckAvailableMemoryByOomL
// -----------------------------------------------------------------------------
//
void CMPXAppUi::CheckAvailableMemoryByOomL( TInt aNeedMemory )
{
ROomMonitorSession oomMonitor;
User::LeaveIfError( oomMonitor.Connect() );
// No leaving code after this point, so no need to use cleanup stack
TInt errorCode = oomMonitor.RequestFreeMemory( aNeedMemory );
oomMonitor.Close();
if ( errorCode != KErrNone )
{
// NOT ENOUGH MEMORY ....Show Information note and exit out..
HBufC* title = StringLoader::LoadLC( R_MPX_NO_MEMORY_INFO );
CAknGlobalNote* infoNote = CAknGlobalNote::NewLC();
infoNote->ShowNoteL(
EAknGlobalInformationNote,
title->Des() );
CleanupStack::PopAndDestroy( infoNote );
CleanupStack::PopAndDestroy( title );
Exit();
}
}
#endif // FF_OOM_MONITOR2_COMPONENT
// End of File