mpxplugins/viewplugins/views/metadataeditordialog/src/mpxmetadataeditordialog.cpp
/*
* 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: Music Player metadata editor dialog implementation
*
*/
// INCLUDE FILES
#include <eikmenub.h>
#include <eikcapc.h>
#include <eikdialg.h> // for dialog functions
#include <eikedwin.h> // for edwins
#include <eikmfne.h> // for number editor
#include <AknPopupFieldText.h>
#include <AknQueryValueText.h>
#include <aknappui.h>
#include <eikspane.h> // for status pane update/restore
#include <akntitle.h> // for title pane
#include <aknnavilabel.h> // for navi label
#include <aknnavi.h>
#include <aknnavide.h>
#include <StringLoader.h>
#include <aknnotewrappers.h>
#include <aknlists.h>
#include <aknclearer.h>
#include <hlplch.h>
#include <bautils.h>
#include <data_caging_path_literals.hrh>
#include <drmrightsmanager.rsg>
#include <centralrepository.h> // for podcasting cenrep key
#include <tz.h>
#include <aknSDData.h>
#include <AknMediatorFacade.h>
#include <mplayersecondarydisplayapi.h>
#include <aknEditStateIndicator.h>
#include <AknIndicatorContainer.h>
#include <avkon.hrh>
#include <avkon.rsg>
#include <mpxmetadataeditordialog.rsg>
#include <mpxcollectionutility.h>
#include <mpxmedia.h>
#include <mpxmediaarray.h>
#include <mpxmediamusicdefs.h>
#include <mpxmediaaudiodefs.h>
#include <mpxmediacontainerdefs.h>
#include <mpxmediadrmdefs.h>
#include <mpxpodcastdefs.h>
#include <mpxcommandgeneraldefs.h>
#include <mpxcollectioncommanddefs.h>
#include <mpxcollectionframeworkdefs.h>
#include <mpxcollectionmessage.h>
#include <mpxcollectionpath.h>
#include <mpxcollectionplaylist.h>
#include <mpxconstants.h>
#include <mpxcollectionhelperfactory.h>
#include <mpxcollectionplugin.hrh>
#include <mpxinternalcrkeys.h>
#include <mpxuser.h>
#include "mpxcommonuihelper.h"
#include "mpxmetadataeditordialog.h"
#include "mpxmetadataeditordialog.hrh"
#include "mpxmetadataeditordialog.hlp.hrh"
#include "mpxlog.h"
#include <drmuihandling.h>
#include <mpxplaybackutility.h>
// CONSTANTS
const TInt KMPXFileDetailsMaxTitleLen = 32;
const TInt KMPXFileDetailsMaxBufferLen = 255;
const TInt KMPXMinNumDateTrack = 0;
const TInt KMPXFileDetailsExtraBufferLen = 10;
const TInt KMPXMaxTimeLength = 36;
const TInt KMPXMaxVal = 512;
const TInt KMPXOneDigit = 10;
const TInt KMPXTwoDigits = 100;
const TInt KMPXBitrateFactor = 1000;
const TInt KSecondInMilliseconds = 1000;
const TInt KOneHourInSeconds = 3600;
const TInt KDigitFive = 5;
const TInt KDigitNine = 9;
const TInt KDigitTen = 10;
const TInt KDigitEleven = 11;
const TInt KDigitFourTeen = 14;
const TInt KDigitHundred = 100;
const TInt KMaxDaysInOneMonths = 31;
const TInt KMaxDaysInTwoMonths = 62;
const TInt KMaxDaysInThreeMonths = 92;
const TInt KMaxDaysInFourMonths = 123;
const TInt KMaxDaysInFiveMonths = 153;
const TInt KMaxDaysInSixMonths = 184;
const TInt KMaxDaysInSevenMonths= 215;
const TInt KMaxDaysInEightMonths = 245;
const TInt KMaxDaysInNineMonths = 276;
const TInt KMaxDaysInTenMonths = 306;
const TInt KMaxDaysInElevenMonths = 337;
const TInt KMaxDaysInTwelveMonths = 366;
// MACROS
_LIT( KMPXMetadataEditorRscPath, "mpxmetadataeditordialog.rsc" );
_LIT( KMPXDrmManagerRscPath, "drmrightsmanager.rsc" );
_LIT( KMPXSpace, " ");
const TInt KMPXDurationDisplayResvLen( 10 );
const TInt64 KSecondInMicroSeconds( 1000000 );
// FUNCTION PROTOTYPES
// ============================ MEMBER FUNCTIONS ===============================
// ----------------------------------------------------------------------------
// CMPXQueryDialog::NewL
// Two-phased constructor.
// ----------------------------------------------------------------------------
//
CMPXQueryDialog* CMPXQueryDialog::NewL()
{
CMPXQueryDialog* self = new (ELeave) CMPXQueryDialog();
return self;
}
// ----------------------------------------------------------------------------
// CMPXQueryDialog::OfferKeyEventL
// Keyevent handler.
// ----------------------------------------------------------------------------
//
TKeyResponse CMPXQueryDialog::OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)
{
// exit from query dialog whever lost forground, currently implementing by mornitor
// application key and end key
if (( aKeyEvent.iScanCode == EStdKeyNo ||
aKeyEvent.iScanCode == EStdKeyApplication0 &&
aType == EEventKey ) ||
( aKeyEvent.iScanCode == EStdKeyApplication6 &&
aType == EEventKeyDown ))
{
TryExitL(EEikBidCancel);
return EKeyWasNotConsumed;
}
else
{
return CAknQueryDialog::OfferKeyEventL( aKeyEvent,aType );
}
}
// ----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::NewL
// Two-phased constructor.
// ----------------------------------------------------------------------------
//
EXPORT_C CMPXMetadataEditorDialog* CMPXMetadataEditorDialog::NewL()
{
MPX_FUNC( "CMPXMetadataEditorDialog::NewL" );
CMPXMetadataEditorDialog* self =
new (ELeave) CMPXMetadataEditorDialog();
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop();
return self;
}
// ----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::~CMPXMetadataEditorDialog
// Destructor.
// ----------------------------------------------------------------------------
//
EXPORT_C CMPXMetadataEditorDialog::~CMPXMetadataEditorDialog()
{
MPX_FUNC( "CMPXMetadataEditorDialog::~CMPXMetadataEditorDialog" );
delete iEmptyNaviDecorator;
delete iTitlePaneText;
delete iCommonUiHelper;
delete iParam;
delete iIdle;
delete iDrmInfo;
if ( iPlaybackUtility )
{
iPlaybackUtility->CancelRequest();
iPlaybackUtility->Close();
}
if ( iCollectionUtility )
{
iCollectionUtility->Close();
}
if ( iCollectionUiHelper )
{
iCollectionUiHelper->Close();
}
if ( iMedia )
{
delete iMedia;
}
if ( iTextValues )
{
delete iTextValues;
}
if ( iValueTextArray )
{
delete iValueTextArray;
}
if ( iGenreArr )
{
delete iGenreArr;
}
if ( iLibraryTextValues )
{
delete iLibraryTextValues;
}
if ( iLibraryValueTextArray )
{
delete iLibraryValueTextArray;
}
if ( iLibraryArr )
{
delete iLibraryArr;
}
if ( iResourceOffset )
{
iEikonEnv->DeleteResourceFile( iResourceOffset );
}
if ( iDrmResourceOffset )
{
iEikonEnv->DeleteResourceFile( iDrmResourceOffset );
}
if(iDrmUiHandler)
{
delete iDrmUiHandler;
}
}
// ----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::SetParamL
// parameter passed in from viewframework
// ----------------------------------------------------------------------------
//
EXPORT_C void CMPXMetadataEditorDialog::SetParamL( const TDesC* aParam )
{
MPX_FUNC( "CMPXMetadataEditorDialog::SetParamL" );
delete iParam;
iParam = NULL;
iParam = aParam->AllocL();
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::OkToExitL
// This function ALWAYS returns ETrue
// -----------------------------------------------------------------------------
//
TBool CMPXMetadataEditorDialog::OkToExitL(TInt aButtonId)
{
MPX_FUNC( "CMPXMetadataEditorDialog::OkToExitL" );
TBool res = EFalse;
switch ( aButtonId )
{
case EAknSoftkeyDone:
{
SaveFormDataL();
RestoreNaviLabelL();
RestoreTitlePaneL();
res = ETrue;
break;
}
case EAknSoftkeyBack:
case EAknSoftkeyExit:
{
RestoreNaviLabelL();
RestoreTitlePaneL();
res = ETrue;
break;
}
case EAknSoftkeyOptions:
default:
{
// display the options menu
res = CAknForm::OkToExitL( aButtonId );
break;
}
}
return res;
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::ExecuteLD
// -----------------------------------------------------------------------------
//
TInt CMPXMetadataEditorDialog::ExecuteLD( TInt /*aResourceId*/ )
{
MPX_FUNC( "CMPXMetadataEditorDialog::ExecuteLD" );
TInt resId = R_MPX_CUI_SONG_DETAILS_DIALOG;
if ( iCurrentLibrary == EMPXMetadataEditorDlgPodcast )
{
resId = R_MPX_CUI_PODCAST_DETAILS_DIALOG;
}
else if( iDisablePodcasting )
{
resId = R_MPX_CUI_SONG_DETAILS_DIALOG_NO_MOVE_LIBRARY;
}
return CAknForm::ExecuteLD( resId );
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::ViewFileDetailsPopupL
// Display file details popup window
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::ViewFileDetailsPopupL()
{
MPX_FUNC( "CMPXMetadataEditorDialog::ViewFileDetailsPopupL" );
CAknDoublePopupMenuStyleListBox* listBox =
new (ELeave) CAknDoublePopupMenuStyleListBox();
CleanupStack::PushL( listBox );
CAknPopupList* popupList = CAknPopupList::NewL(
listBox,
R_AVKON_SOFTKEYS_OK_EMPTY,
AknPopupLayouts::EMenuDoubleWindow );
CleanupStack::PushL( popupList );
listBox->ConstructL( popupList, CEikListBox::ELeftDownInViewRect );
listBox->CreateScrollBarFrameL( ETrue );
listBox->ScrollBarFrame()->SetScrollBarVisibilityL(
CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto );
// Enable Marquee
static_cast<CEikFormattedCellListBox*>
( listBox )->ItemDrawer()->ColumnData()->EnableMarqueeL( ETrue );
// Retrieve heading array
CDesCArrayFlat* headingsArray = NULL;
TInt itemCount = 0;
if ( iCurrentLibrary == EMPXMetadataEditorDlgCollection )
{
headingsArray = iCoeEnv->ReadDesCArrayResourceL(
R_MPX_CUI_FD_HEADINGS_SONGS );
itemCount = EMPXSongsFileDetailsHeadingCount;
}
else if ( iCurrentLibrary == EMPXMetadataEditorDlgPodcast )
{
headingsArray = iCoeEnv->ReadDesCArrayResourceL(
R_MPX_CUI_FD_HEADINGS_PODCASTS );
itemCount = EMPXPodcastsFileDetailsHeadingCount;
}
else
{
User::Leave( KErrArgument );
}
CleanupStack::PushL( headingsArray );
CAknLocalScreenClearer* clearer = CAknLocalScreenClearer::NewLC( EFalse );
CDesCArray* itemArray =
static_cast<CDesCArray*>( listBox->Model()->ItemTextArray() );
CDesCArrayFlat* dataArray =
new ( ELeave ) CDesCArrayFlat( itemCount );
CleanupStack::PushL( dataArray );
if ( iMedia )
{
PopulateFileDetailsL( headingsArray, dataArray );
// item count might have been updated due to addition of
// DRM content details
itemCount = headingsArray->MdcaCount();
}
else
{
// properties not available
for ( TInt i = 0; i < itemCount; i++ )
{
dataArray->AppendL( KNullDesC );
}
}
for ( TInt i = 0; i < itemCount; i++ )
{
AddItemToListBoxL( headingsArray->MdcaPoint( i ), dataArray->MdcaPoint( i ), itemArray );
}
CleanupStack::PopAndDestroy( dataArray );
CleanupStack::PopAndDestroy( clearer );
CleanupStack::PopAndDestroy( headingsArray );
// Set title
TBuf<KMPXFileDetailsMaxTitleLen> title;
iCoeEnv->ReadResourceL( title, R_MPX_CUI_FD_TITLE );
popupList->SetTitleL( title );
// Show popup list
popupList->ExecuteLD();
CleanupStack::Pop();
CleanupStack::PopAndDestroy( listBox );
}
// ---------------------------------------------------------------------------
// From MMPXCollectionObserver
// Handle collection message.
// ---------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::HandleCollectionMessage(
CMPXMessage* /*aMessage*/, TInt /*aError*/ )
{
// do nothing
}
// ---------------------------------------------------------------------------
// From MMPXCollectionObserver
// Handles the collection entries being opened. Typically called
// when client has Open()'d a folder
// ---------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::HandleOpenL(
const CMPXMedia& /*aEntries*/,
TInt /*aIndex*/, TBool /*aComplete*/, TInt /*aError*/ )
{
// do nothing
}
// ---------------------------------------------------------------------------
// From MMPXCollectionObserver
// Handles the item being opened. Typically called
// when client has Open()'d an item. Client typically responds by
// 'playing' the item via the playlist
// ---------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::HandleOpenL(
const CMPXCollectionPlaylist& /*aPlaylist*/, TInt /*aError*/ )
{
// do nothing
}
// ---------------------------------------------------------------------------
// From MMPXCollectionObserver
// Handle media properties.
// Notes: The client is responsible for delete the object of aMedia.
// ---------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::HandleCollectionMediaL(
const CMPXMedia& aMedia,
TInt aError )
{
MPX_FUNC( "CMPXMetadataEditorDialog::HandleCollectionMediaL" );
TRAP_IGNORE( DoHandleMediaL( aMedia, aError ) );
}
// ----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::CMPXMetadataEditorDialog
// C++ default constructor can NOT contain any code, that
// might leave.
// ----------------------------------------------------------------------------
//
CMPXMetadataEditorDialog::CMPXMetadataEditorDialog()
{
// do nothing
}
// ----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::ConstructL
// Symbian 2nd phase constructor can leave.
// ----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::ConstructL()
{
MPX_FUNC( "CMPXMetadataEditorDialog::ConstructL" );
CCoeEnv* coeEnv = iEikonEnv;
TParse parse;
parse.Set( KMPXMetadataEditorRscPath, &KDC_APP_RESOURCE_DIR, NULL );
TFileName resourceFile( parse.FullName() );
User::LeaveIfError( MPXUser::CompleteWithDllPath( resourceFile ) );
BaflUtils::NearestLanguageFile( coeEnv->FsSession(), resourceFile );
iResourceOffset = coeEnv->AddResourceFileL( resourceFile );
parse.Set( KMPXDrmManagerRscPath, &KDC_APP_RESOURCE_DIR, NULL );
TFileName drmResourceFile( parse.FullName() );
User::LeaveIfError( MPXUser::CompleteWithDllPath( drmResourceFile ) );
BaflUtils::NearestLanguageFile( coeEnv->FsSession(), drmResourceFile );
TRAPD(drmResourceError,iDrmResourceOffset = coeEnv->AddResourceFileL( drmResourceFile ));
iDrmDetails = (drmResourceError == KErrNone) ? ETrue: EFalse;
iCollectionUtility = MMPXCollectionUtility::NewL( this, KMcModeDefault );
iCommonUiHelper = CMPXCommonUiHelper::NewL();
CAknForm::ConstructL( R_MPX_CUI_SONG_DETAILS_MENUBAR );
iCurrentLibrary = EMPXMetadataEditorDlgCollection;
// check if it's podcast collection
CMPXCollectionPath* cpath = iCollectionUtility->Collection().PathL();
CleanupStack::PushL( cpath );
if ( cpath->Levels() > 0 )
{
RArray<TUid> ary;
CleanupClosePushL( ary );
ary.AppendL( TUid::Uid(EMPXCollectionPluginPodCast) );
TUid podcastUid = iCollectionUtility->CollectionIDL( ary.Array() );
CleanupStack::PopAndDestroy( &ary );
if ( cpath->Id( 0 ) == podcastUid.iUid )
{
MPX_DEBUG1( "CMPXMetadataEditorDialog::ConstructL Podcast collection" );
iCurrentLibrary = EMPXMetadataEditorDlgPodcast;
}
}
iCollectionUiHelper = CMPXCollectionHelperFactory::NewCollectionUiHelperL();
CleanupStack::PopAndDestroy( cpath );
// Get podcasting key
TInt val(0);
CRepository* repository = CRepository::NewL( KCRUidMPXMPFeatures );
repository->Get( KMPXMPLocalVariation, val );
iDisablePodcasting = val&KMPXDisablePodcastingOption ? ETrue : EFalse;
delete repository;
//DRM information popup
iDrmUiHandler = DRM::CDrmUiHandling::NewL();
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::CleanUpGenreText
// Clean up function for genre related members.
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::CleanUpGenreText()
{
MPX_FUNC( "CMPXMetadataEditorDialog::CleanUpGenreText" );
if ( iGenreArr )
{
delete iGenreArr;
iGenreArr = NULL;
}
if ( iValueTextArray )
{
delete iValueTextArray;
iValueTextArray = NULL;
}
if ( iTextValues )
{
delete iTextValues;
iTextValues = NULL;
}
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::FetchGenreL
// Populates genre popup with genre list for tracks.
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::FetchGenreL()
{
MPX_FUNC( "CMPXMetadataEditorDialog::FetchGenreL" );
RArray<TMPXAttribute> attrs;
CleanupClosePushL( attrs );
attrs.Append( KMPXMediaGeneralTitle );
CMPXMedia* criteria = CMPXMedia::NewL();
CleanupStack::PushL( criteria );
criteria->SetTObjectValueL<TUid>(
KMPXMediaGeneralCollectionId, TUid::Uid( 0x101FFC3A ) );
criteria->SetTObjectValueL<TMPXGeneralType>(
KMPXMediaGeneralType, EMPXGroup );
criteria->SetTObjectValueL<TMPXGeneralCategory>(
KMPXMediaGeneralCategory, EMPXGenre );
iCollectionUtility->Collection().FindAllL( *criteria, attrs.Array(), *this );
CleanupStack::PopAndDestroy( criteria );
CleanupStack::PopAndDestroy( &attrs );
}
// ---------------------------------------------------------------------------
// Handle media properties.
// ---------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::DoHandleMediaL(
const CMPXMedia& aMedia,
TInt aError )
{
MPX_FUNC( "CMPXMetadataEditorDialog::DoHandleMediaL" );
if ( iCurrentMediaLOp == EMPXMetadataEditorGetSongInfo )
{
delete iMedia;
iMedia = NULL;
if ( aError == KErrNone )
{
iMedia = CMPXMedia::NewL( aMedia );
// common for both music and podcast
// Fetch the artist
if ( iMedia->IsSupported( KMPXMediaDrmProtected ) )
{
iIsDrmProtected = iMedia->ValueTObjectL<TBool>( KMPXMediaDrmProtected );
}
SetControlTextL( EMPXMetadataEditorDlgCtrlIdArtist,
iMedia->ValueText( KMPXMediaMusicArtist ), KNullDesC );
// Fetch the album
SetControlTextL( EMPXMetadataEditorDlgCtrlIdAlbum,
iMedia->ValueText( KMPXMediaMusicAlbum ), KNullDesC );
// Fetch the track number
SetControlNumberL( EMPXMetadataEditorDlgCtrlIdTrackNumber,
iMedia->ValueText( KMPXMediaMusicAlbumTrack ),
KMPXSongDetailsTrackNumMin, KMPXSongDetailsTrackNumMax );
// Fetch the year
TInt64 year(0);
if ( iMedia->IsSupported (KMPXMediaMusicYear ) )
{
year = iMedia->ValueTObjectL<TInt64>( KMPXMediaMusicYear );
}
TTime yearTime( year);
iYear = yearTime.DateTime().Year ( );
HBufC* yearBuf = HBufC::NewLC ( KMPXMaxTimeLength );
yearBuf->Des().AppendNum ( iYear );
SetControlNumberL ( EMPXMetadataEditorDlgCtrlIdYear, *yearBuf,
KMPXSongDetailsYearMin, KMPXSongDetailsYearMax );
CleanupStack::PopAndDestroy ( yearBuf );
// Fetch genre
FetchGenreL();
// Fetch the comment
SetControlTextL( EMPXMetadataEditorDlgCtrlIdComment,
iMedia->ValueText( KMPXMediaGeneralComment ), KNullDesC );
// Fetch the song name
TParsePtrC fileDetail( iMedia->ValueText( KMPXMediaGeneralUri ) );
SetControlTextL( EMPXMetadataEditorDlgCtrlIdSongName,
iMedia->ValueText( KMPXMediaGeneralTitle ), fileDetail.Name() );
if ( iCurrentLibrary == EMPXMetadataEditorDlgCollection )
{
// Fetch the composer
SetControlTextL( EMPXMetadataEditorDlgCtrlIdComposer,
iMedia->ValueText( KMPXMediaMusicComposer ), KNullDesC );
}
PopulateFileDetailsL();
DrawNow();
}
else
{
// if error getting metadata, exit editor
iCommonUiHelper->HandleErrorL( aError );
if ( iIdle )
{
iIdle->Cancel();
delete iIdle;
iIdle = NULL;
}
iIdle = CIdle::NewL( CActive::EPriorityStandard );
iIdle->Start( TCallBack( CMPXMetadataEditorDialog::DeferredExitCallback, this ) );
}
}
else if ( iCurrentMediaLOp == EMPXMetadataEditorGetDrmInfo )
{
delete iDrmInfo;
iDrmInfo = NULL;
if ( aError == KErrNone )
{
iDrmInfo = CMPXMedia::NewL( aMedia );
}
else
{
iDrmInfo = CMPXMedia::NewL();
}
if ( iIdle )
{
iIdle->Cancel();
delete iIdle;
iIdle = NULL;
}
iIdle = CIdle::NewL( CActive::EPriorityStandard );
iIdle->Start( TCallBack( CMPXMetadataEditorDialog::DeferredFileDetailsCallback, this ) );
}
else
{
// Should not reach here
ASSERT( 0 );
}
iCurrentMediaLOp = EMPXMetadataEditorIdle;
}
// ----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::SaveFormDataL
// Save form data.
// ----------------------------------------------------------------------------
//
TBool CMPXMetadataEditorDialog::SaveFormDataL()
{
MPX_FUNC( "CMPXMetadataEditorDialog::SaveFormDataL" );
if ( iMedia )
{
MPX_DEBUG1( "CMPXMetadataEditorDialog::SaveFormDataL Saving.." );
CMPXMedia* media = CMPXMedia::NewL();
CleanupStack::PushL( media );
TBool changed = EFalse;
// common to both music and podcast
// update local copy of media as well because getting media prop is slow
changed = UpdateMediaObjectWithControlL( EMPXMetadataEditorDlgCtrlIdSongName,
media, KMPXMediaGeneralTitle );
changed = UpdateMediaObjectWithControlL( EMPXMetadataEditorDlgCtrlIdArtist,
media, KMPXMediaMusicArtist ) || changed;
changed = UpdateMediaObjectWithControlL( EMPXMetadataEditorDlgCtrlIdAlbum,
media, KMPXMediaMusicAlbum ) || changed;
changed = UpdateMediaObjectWithControlL( EMPXMetadataEditorDlgCtrlIdTrackNumber,
media, KMPXMediaMusicAlbumTrack ) || changed;
changed = UpdateMediaObjectWithControlL( EMPXMetadataEditorDlgCtrlIdComment,
media, KMPXMediaGeneralComment ) || changed;
// special handling needed for year
CCoeControl* coeControl = ControlOrNull( EMPXMetadataEditorDlgCtrlIdYear );
if ( coeControl )
{
CEikEdwin* control = static_cast<CEikEdwin*>( coeControl );
if ( control )
{
TBuf<KMPXSongDetailsNumTextWidth> num;
control->GetText( num );
TLex numLex( num );
TInt LexToInt;
numLex.Val( LexToInt );
if ( LexToInt != iYear )
{
MPX_DEBUG3( "CMPXMetadataEditorDialog::SaveFormDataL year changed from %d to %d", iYear, num );
TDateTime newYear;
newYear.Set( LexToInt, EJanuary, 0, 0, 0, 0, 0 );
TTime year( newYear );
iMedia->SetTObjectValueL<TInt64>(
KMPXMediaMusicYear, year.Int64() );
media->SetTObjectValueL<TInt64>(
KMPXMediaMusicYear, year.Int64() );
iYear = LexToInt;
changed = ETrue;
}
else
{
MPX_DEBUG1( "CMPXMetadataEditorDialog::SaveFormDataL year not changed" );
}
}
}
if ( iCurrentLibrary == EMPXMetadataEditorDlgCollection )
{
changed = UpdateMediaObjectWithControlL( EMPXMetadataEditorDlgCtrlIdComposer,
media, KMPXMediaMusicComposer ) || changed;
}
else if ( iCurrentLibrary == EMPXMetadataEditorDlgPodcast )
{
// no special handling, all covered in common
}
if ( changed )
{
// save it back to collection engine
SaveMediaPropertiesL( media );
MPX_DEBUG1( "CMPXMetadataEditorDialog::SaveFormDataL Saved" );
}
#ifdef _DEBUG
else
{
MPX_DEBUG1( "CMPXMetadataEditorDialog::SaveFormDataL All equal, not saved" );
}
#endif
CleanupStack::PopAndDestroy( media );
}
return ETrue;
}
// ----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::DoNotSaveFormDataL
// Does not save form data.
// ----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::DoNotSaveFormDataL()
{
// Do nothing
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::SetTitlePane
// Set Title Pane from descriptor.
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::SetTitlePaneL()
{
MPX_FUNC( "CMPXMetadataEditorDialog::SetTitlePaneL" );
// Saving the current title before it's overwritten
CEikStatusPane* statusPane = iAvkonAppUi->StatusPane();
iTitlePane =
static_cast<CAknTitlePane*>
( statusPane->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) );
const TDesC* text = iTitlePane->Text();
iTitlePaneText = text->AllocL();
HBufC* newText = NULL;
if ( iCurrentLibrary == EMPXMetadataEditorDlgCollection )
{
newText = StringLoader::LoadLC( R_MPX_CUI_SONG_DETAILS_TITLE );
}
else if ( iCurrentLibrary == EMPXMetadataEditorDlgPodcast )
{
newText = StringLoader::LoadLC( R_MPX_CUI_SONG_DETAILS_EPISODE );
}
// Update Title Pane
if ( newText )
{
iTitlePane->SetTextL( *newText );
}
CleanupStack::PopAndDestroy( newText );
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::RestoreTitlePane
// Restore Title Pane from the member data.
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::RestoreTitlePaneL()
{
MPX_FUNC( "CMPXMetadataEditorDialog::RestoreTitlePaneL" );
// Update Title Pane
iTitlePane->SetTextL( *iTitlePaneText );
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::SetNaviLabelL
// Set Navi Label from descriptor.
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::SetNaviLabelL()
{
MPX_FUNC( "CMPXMetadataEditorDialog::SetNaviLabelL" );
MAknEditingStateIndicator *editingStateIndicator = CAknEnv::Static()->EditingStateIndicator();
CAknIndicatorContainer* indicContainerEditing = editingStateIndicator->IndicatorContainer();
indicContainerEditing->SetIndicatorValueL( TUid::Uid( EAknNaviPaneEditorIndicatorMessageInfo), KNullDesC );
// Saving the current title before it's overwritten
CEikStatusPane* statusPane = iAvkonAppUi->StatusPane();
iNaviPane = static_cast<CAknNavigationControlContainer*>
( statusPane->ControlL( TUid::Uid( EEikStatusPaneUidNavi ) ) );
// store the latest navi pane
iNaviDecorator = iNaviPane->Top();
if(iNaviDecorator)
{
// set the new navi label
iEmptyNaviDecorator =
iNaviPane->CreateNavigationLabelL(KNullDesC);
iNaviPane->PushL( *iEmptyNaviDecorator );
}
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::RestoreNaviLabelL
// Restore Navi Label from the member data.
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::RestoreNaviLabelL()
{
MPX_FUNC( "CMPXMetadataEditorDialog::RestoreNaviLabelL" );
iNaviPane->Pop( iEmptyNaviDecorator ); // pop out the empty navi
if ( iNaviDecorator )
{
iNaviPane->PushL( *iNaviDecorator );
}
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::DynInitMenuPaneL
// Dynamically initialises a menu pane.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::DynInitMenuPaneL(
TInt aResourceId,
CEikMenuPane* aMenuPane)
{
MPX_FUNC( "CMPXMetadataEditorDialog::DynInitMenuPaneL" );
CAknForm::DynInitMenuPaneL(aResourceId, aMenuPane);
if ( aResourceId == R_AVKON_FORM_MENUPANE )
{
if ( ( IdOfFocusControl() == EMPXMetadataEditorDlgCtrlIdGenre ) ||
( IdOfFocusControl() == EMPXMetadataEditorDlgCtrlIdLibrary ) )
{
aMenuPane->SetItemDimmed( EMPXCmdSongDetailsChange, ETrue );
}
else
{
aMenuPane->SetItemDimmed( EMPXCmdSongDetailsChange, ETrue );
}
aMenuPane->SetItemDimmed( EMPXCmdSongDetails, ETrue );
// Dim out the Avkon menu items
aMenuPane->SetItemDimmed( EAknFormCmdEdit, ETrue );
aMenuPane->SetItemDimmed( EAknFormCmdAdd, ETrue );
aMenuPane->SetItemDimmed( EAknFormCmdSave, ETrue );
aMenuPane->SetItemDimmed( EAknFormCmdLabel, ETrue );
aMenuPane->SetItemDimmed( EAknFormCmdDelete, ETrue );
}
}
// ----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::ProcessCommandL
// Act on the menu selection if menu is showing.
// ----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::ProcessCommandL( TInt aCommandId )
{
MPX_FUNC( "CMPXMetadataEditorDialog::ProcessCommandL" );
CAknForm::ProcessCommandL(aCommandId);
switch (aCommandId)
{
case EMPXCmdSongDetailsChange:
{
if ( IdOfFocusControl() == EMPXMetadataEditorDlgCtrlIdGenre )
{
iPopup = static_cast<CAknPopupField*>
( ControlOrNull( EMPXMetadataEditorDlgCtrlIdGenre ) );
}
else if ( IdOfFocusControl() == EMPXMetadataEditorDlgCtrlIdLibrary )
{
iPopup = static_cast<CAknPopupField*>
( ControlOrNull( EMPXMetadataEditorDlgCtrlIdLibrary ) );
}
if ( iPopup )
{
iPopup->ActivateSelectionListL();
}
break;
}
case EMPXCmdSongDetails:
{
if ( iIsDrmProtected && !iDrmInfo )
{
CMPXCollectionPath* cpath = iCollectionUtility->Collection().PathL();
CleanupStack::PushL( cpath );
if ( iParam )
{
TLex yearLex( iParam->Des() );
TInt lexToInt = NULL;
if ( yearLex.Val( lexToInt ) == KErrNone )
{
cpath->Set( lexToInt );
RArray<TMPXAttribute> attrs;
CleanupClosePushL(attrs);
attrs.Append( KMPXMediaGeneralUri );
attrs.Append( KMPXMediaDrmAll );
iCurrentMediaLOp = EMPXMetadataEditorGetDrmInfo;
iCollectionUtility->Collection().MediaL( *cpath, attrs.Array() );
CleanupStack::PopAndDestroy( &attrs );
}
}
CleanupStack::PopAndDestroy( cpath );
}
else
{
if( iMedia )
{
ViewFileDetailsPopupL();
}
}
break;
}
case EAknCmdHelp:
{
TCoeHelpContext helpContext;
GetHelpContext( helpContext );
CArrayFixFlat<TCoeHelpContext>* array =
new(ELeave)CArrayFixFlat<TCoeHelpContext>( 1 );
CleanupStack::PushL( array );
array->AppendL( helpContext );
CleanupStack::Pop(); // array
// HlpLauncher deletes array
HlpLauncher::LaunchHelpApplicationL( iEikonEnv->WsSession(), array );
break;
}
case EAknCmdExit:
{
static_cast<MEikCommandObserver*>(iEikonEnv->EikAppUi())->
ProcessCommandL(aCommandId);
}
default :
break;
}
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::PopulateFileDetailsL
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::PopulateFileDetailsL(
CDesCArrayFlat* aHeadingsArray, CDesCArrayFlat* aDataArray )
{
MPX_FUNC( "CMPXMetadataEditorDialog::PopulateFileDetailsL" );
TBool drmProtected( iMedia->ValueTObjectL<TBool>( KMPXMediaDrmProtected ) );
MPX_DEBUG2( "CMPXMetadataEditorDialog::PopulateFileDetailsL drm protected: %d", drmProtected );
if ( drmProtected )
{
MakeDrmItemsL( aHeadingsArray, aDataArray );
}
// Get filename
const TDesC& uri = iMedia->ValueText( KMPXMediaGeneralUri );
TParsePtrC parse(uri);
AppendStringToArrayL( aDataArray, parse.Name() );
// Get mime type
const TDesC& mimeType = iMedia->ValueText( KMPXMediaGeneralMimeType );
AppendStringToArrayL( aDataArray, mimeType );
// Get duration
TInt duration( iMedia->ValueTObjectL<TInt>( KMPXMediaGeneralDuration ) );
if ( duration > 0 )
{
// convert milliseconds to seconds
duration = duration / KSecondInMilliseconds;
CMPXCommonUiHelper::TMPXDuratDisplayMode durationMode =
CMPXCommonUiHelper::EMPXDuratAuto;
if ( duration > KOneHourInSeconds )
{
durationMode = CMPXCommonUiHelper::EMPXDuratHMS;
}
HBufC* stringBuf = iCommonUiHelper->DisplayableDurationL(
duration, durationMode );
CleanupStack::PushL( stringBuf );
aDataArray->AppendL( *stringBuf );
CleanupStack::PopAndDestroy( stringBuf );
}
else
{
aDataArray->AppendL( KNullDesC );
}
// Get bitrate
TInt bitrate( iMedia->ValueTObjectL<TInt>( KMPXMediaAudioBitrate ) );
if ( bitrate > 0 )
{
// convert bitrate to kpbs
bitrate = bitrate / KMPXBitrateFactor;
HBufC* bitrateText = StringLoader::LoadLC(
R_MPX_CUI_METADATAEDITOR_BITRATE_TXT, bitrate );
aDataArray->AppendL( bitrateText->Des() );
CleanupStack::PopAndDestroy( bitrateText );
}
else
{
aDataArray->AppendL( KNullDesC );
}
// Get sampling rate
TInt samplingRateNum( ( TInt )iMedia->ValueTObjectL<TInt>( KMPXMediaAudioSamplerate ) );
if ( samplingRateNum > 0 )
{
HBufC* stringBuf = HBufC::NewLC( KMPXFileDetailsMaxBufferLen );
TPtr stringBufPtr = stringBuf->Des();
stringBufPtr.AppendNum( samplingRateNum );
AknTextUtils::LanguageSpecificNumberConversion( stringBufPtr );
HBufC* samplingrate = StringLoader::LoadLC(
R_MPX_CUI_METADATAEDITOR_SAMPLINGRATE_TXT, stringBufPtr );
aDataArray->AppendL( samplingrate->Des() );
CleanupStack::PopAndDestroy( samplingrate );
CleanupStack::PopAndDestroy( stringBuf );
}
else
{
aDataArray->AppendL( KNullDesC );
}
// Get size, not stored in collection, have to use RFile
//
RFs& fs = CEikonEnv::Static()->FsSession();
RFile file;
TInt sizeNum(0);
TInt err ( file.Open( fs, uri, EFileRead | EFileShareReadersOrWriters ) );
if ( err == KErrNone )
{
file.Size(sizeNum);
file.Close();
}
if ( sizeNum > 0 )
{
HBufC* stringBuf = iCommonUiHelper->UnitConversionL( sizeNum );
CleanupStack::PushL( stringBuf );
aDataArray->AppendL( *stringBuf );
CleanupStack::PopAndDestroy( stringBuf );
}
else
{
aDataArray->AppendL( KNullDesC );
}
if ( iCurrentLibrary == EMPXMetadataEditorDlgPodcast )
{
PopulatePodcastFileDetailsL( aHeadingsArray, aDataArray );
}
// Get modified
TTime time;
User::LeaveIfError( fs.Modified( uri, time ) );
ConvertToLocalTimeL( time );
HBufC* modDateTime = HBufC::NewLC(
KMPXMaxTimeLength + KMPXDurationDisplayResvLen );
HBufC* format = StringLoader::LoadLC(
R_QTN_DATE_USUAL_WITH_ZERO );
TPtr modDatePtr = modDateTime->Des();
MPX_TRAPD( error, time.FormatL( modDatePtr, *format ) );
CleanupStack::PopAndDestroy( format );
if (error != KErrNone)
{
aDataArray->AppendL( KNullDesC );
}
else
{
format = StringLoader::LoadLC(
R_QTN_TIME_USUAL_WITH_ZERO );
HBufC* modTime = HBufC::NewLC(
format->Length() + KMPXDurationDisplayResvLen );
TPtr modTimePtr = modTime->Des();
MPX_TRAPD( err, time.FormatL( modTimePtr, *format ) );
if ( err != KErrNone )
{
aDataArray->AppendL( KNullDesC );
}
else
{
modDatePtr.Append( KMPXSpace );
modDatePtr.Append( modTimePtr );
aDataArray->AppendL( modDatePtr );
}
CleanupStack::PopAndDestroy( modTime );
CleanupStack::PopAndDestroy( format );
}
CleanupStack::PopAndDestroy( modDateTime );
// Get filename
AppendStringToArrayL( aDataArray, iMedia->ValueText(
KMPXMediaGeneralCopyright ) );
// Get URL
AppendStringToArrayL( aDataArray, iMedia->ValueText(
KMPXMediaMusicURL ) );
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::PopulatePodcastFileDetailsL
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::PopulatePodcastFileDetailsL(
CDesCArrayFlat* /*aHeadingsArray*/, CDesCArrayFlat* aDataArray )
{
MPX_FUNC( "CMPXMetadataEditorDialog::PopulatePodcastFileDetailsL" );
// Get last playback position
TInt lastPbPosition( ( TInt )iMedia->ValueTObjectL<TInt>(
KMPXMediaGeneralLastPlaybackPosition ) );
if ( lastPbPosition > 0 )
{
// convert milliseconds to seconds
lastPbPosition = lastPbPosition / KSecondInMilliseconds;
CMPXCommonUiHelper::TMPXDuratDisplayMode lastPbPositionMode =
CMPXCommonUiHelper::EMPXDuratAuto;
if ( lastPbPosition > KOneHourInSeconds )
{
lastPbPositionMode = CMPXCommonUiHelper::EMPXDuratHMS;
}
HBufC* stringBuf = iCommonUiHelper->DisplayableDurationL(
lastPbPosition, lastPbPositionMode );
CleanupStack::PushL( stringBuf );
aDataArray->AppendL( *stringBuf );
CleanupStack::PopAndDestroy( stringBuf );
}
else if(lastPbPosition == 0 &&
iMedia->IsSupported(KMPXMediaGeneralPlayCount) &&
iMedia->ValueTObjectL<TInt>(KMPXMediaGeneralPlayCount) > 0 )
{
HBufC* stringBuf = StringLoader::LoadLC( R_MPX_CUI_METADATAEDITOR_PLAYBACK_COMPLETE );
aDataArray->AppendL( *stringBuf );
CleanupStack::PopAndDestroy( stringBuf );
}
else
{
aDataArray->AppendL( KNullDesC );
}
// Get published
if ( iMedia->IsSupported( TMPXAttribute( KMPXMediaIdPodcast,
EMPXMediaPodcastPubDate ) ) )
{
TInt64 timeInt( ( TInt64 )iMedia->ValueTObjectL<TInt64>(
TMPXAttribute( KMPXMediaIdPodcast, EMPXMediaPodcastPubDate ) ) );
TTime time( timeInt );
ConvertToLocalTimeL(time);
HBufC* modDateTime = HBufC::NewLC(
KMPXMaxTimeLength + KMPXDurationDisplayResvLen );
HBufC* format = StringLoader::LoadLC(
R_QTN_DATE_USUAL_WITH_ZERO );
TPtr modDatePtr = modDateTime->Des();
MPX_TRAPD( err, time.FormatL( modDatePtr, *format ) );
CleanupStack::PopAndDestroy( format );
if (err != KErrNone ||
time == 0)
{
aDataArray->AppendL( KNullDesC );
}
else
{
format = StringLoader::LoadLC(
R_QTN_TIME_USUAL_WITH_ZERO );
HBufC* modTime = HBufC::NewLC(
format->Length() + KMPXDurationDisplayResvLen );
TPtr modTimePtr = modTime->Des();
MPX_TRAPD( err, time.FormatL( modTimePtr, *format ) );
if ( err != KErrNone )
{
aDataArray->AppendL( KNullDesC );
}
else
{
modDatePtr.Append( KMPXSpace );
modDatePtr.Append( modTimePtr );
aDataArray->AppendL( modDatePtr );
}
CleanupStack::PopAndDestroy( modTime );
CleanupStack::PopAndDestroy( format );
}
CleanupStack::PopAndDestroy( modDateTime );
}
else
{
aDataArray->AppendL( KNullDesC );
}
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::MakeDrmItemsL
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::MakeDrmItemsL(
CDesCArrayFlat* aHeadingsArray, CDesCArrayFlat* aDataArray )
{
MPX_FUNC( "CMPXMetadataEditorDialog::MakeDrmItemsL" );
if (iDrmDetails )
{
TInt itemCount( 0);
if ( iDrmInfo->IsSupported( KMPXMediaDrmType ) )
{
MPX_DEBUG2( "CMPXMetadataEditorDialog::MakeDrmItemsL drm type: %d",
iDrmInfo->ValueTObjectL<TInt>( KMPXMediaDrmType ) );
TInt rightStatus( iDrmInfo->ValueTObjectL<TInt>( KMPXMediaDrmRightsStatus ) );
HBufC* rights( StringLoader::LoadLC( R_QTN_DRM_MGR_DET2_PLAY ) );
HBufC* heading( NULL);
HBufC* value( NULL);
switch ( rightStatus )
{
case EMPXDrmRightsFull:
{
// status
heading = StringLoader::LoadLC ( R_QTN_DRM_MGR_DET_STAT );
value = StringLoader::LoadLC ( R_QTN_DRM_MGR_DET_VALID );
aHeadingsArray->InsertL ( itemCount, heading->Des ( ) );
aDataArray->InsertL ( itemCount, value->Des ( ) );
CleanupStack::PopAndDestroy ( value );
CleanupStack::PopAndDestroy ( heading );
itemCount++;
// full rights
heading = StringLoader::LoadLC (
R_QTN_DRM_MGR_DET_FULL_X, *rights );
value = StringLoader::LoadLC ( R_QTN_DRM_MGR_DET_UNLIMITED );
aHeadingsArray->InsertL ( itemCount, heading->Des ( ) );
aDataArray->InsertL ( itemCount, value->Des ( ) );
CleanupStack::PopAndDestroy ( value );
CleanupStack::PopAndDestroy ( heading );
itemCount++;
break;
}
case EMPXDrmRightsRestricted:
case EMPXDrmRightsPreview:
{
// status
heading = StringLoader::LoadLC ( R_QTN_DRM_MGR_DET_STAT );
value = StringLoader::LoadLC ( R_QTN_DRM_MGR_DET_VALID );
aHeadingsArray->InsertL ( itemCount, heading->Des ( ) );
aDataArray->InsertL ( itemCount, value->Des ( ) );
CleanupStack::PopAndDestroy ( value );
CleanupStack::PopAndDestroy ( heading );
itemCount++;
// rights
MakeRestrictedDrmItemsL(
rights, itemCount, aHeadingsArray, aDataArray );
break;
}
case EMPXDrmRightsMissing:
{
// status
heading = StringLoader::LoadLC ( R_QTN_DRM_MGR_DET_STAT );
value = StringLoader::LoadLC ( R_QTN_DRM_MGR_DET_EXP );
aHeadingsArray->InsertL ( itemCount, heading->Des ( ) );
aDataArray->InsertL ( itemCount, value->Des ( ) );
CleanupStack::PopAndDestroy ( value );
CleanupStack::PopAndDestroy ( heading );
itemCount++;
break;
}
case EMPXDrmRightsExpired:
{
// status
heading = StringLoader::LoadLC ( R_QTN_DRM_MGR_DET_STAT );
value = StringLoader::LoadLC ( R_QTN_DRM_MGR_DET_EXP );
aHeadingsArray->InsertL ( itemCount, heading->Des ( ) );
aDataArray->InsertL ( itemCount, value->Des ( ) );
CleanupStack::PopAndDestroy ( value );
CleanupStack::PopAndDestroy ( heading );
itemCount++;
// make rest of the drm items
MakeRestrictedDrmItemsL(
rights, itemCount, aHeadingsArray, aDataArray );
break;
}
default:
{
break;
}
}
heading = NULL;
value = NULL;
// sending
heading = StringLoader::LoadLC ( R_QTN_DRM_MGR_DET_CS );
TBool forwardAllowed( iDrmInfo->ValueTObjectL<TBool>( KMPXMediaDrmSendingAllowed ) );
if ( forwardAllowed )
{
value = StringLoader::LoadLC ( R_QTN_DRM_MGR_DET_ALLOWED );
}
else
{
value = StringLoader::LoadLC ( R_QTN_DRM_MGR_DET_FORBID );
}
aHeadingsArray->InsertL ( itemCount, heading->Des ( ) );
aDataArray->InsertL ( itemCount, value->Des ( ) );
CleanupStack::PopAndDestroy ( value );
CleanupStack::PopAndDestroy ( heading );
CleanupStack::PopAndDestroy ( rights ); // heading, value, rights
}
else
{
// if error getting drm info, drm type will not be valid
// by default assume the rights are invalid (since we can't read it)
MPX_DEBUG1( "CMPXMetadataEditorDialog::MakeDrmItemsL unable to get drm data" );
HBufC* heading( StringLoader::LoadLC ( R_QTN_DRM_MGR_DET_STAT ));
HBufC* value( StringLoader::LoadLC ( R_QTN_DRM_MGR_DET_INVALID ));
aHeadingsArray->InsertL ( 0, heading->Des ( ) );
aDataArray->InsertL ( 0, value->Des ( ) );
CleanupStack::PopAndDestroy ( value );
CleanupStack::PopAndDestroy ( heading );
}
}
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::MakeRestrictedDrmItemsL
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::MakeRestrictedDrmItemsL(
HBufC* aRights, TInt& aCurrentIndex,
CDesCArrayFlat* aHeadingsArray, CDesCArrayFlat* aDataArray )
{
MPX_FUNC( "CMPXMetadataEditorDialog::MakeRestrictedDrmItemsL" );
TMPXMediaDrmRightsType expireConstraint( EMPXDrmRightsTypeNoRestriction );
if ( iDrmInfo->IsSupported( KMPXMediaDrmRightsType ) )
{
expireConstraint = iDrmInfo->ValueTObjectL<TMPXMediaDrmRightsType>(
KMPXMediaDrmRightsType );
}
MPX_DEBUG2("CMPXMetadataEditorDialog::MakeRestrictedDrmItemsL(): ExpireConstraint = %d", expireConstraint);
TInt64 intervalTime( KErrNotFound );
if ( iDrmInfo->IsSupported( KMPXMediaDrmIntervalStartTime ) )
{
MPX_DEBUG1("CMPXMetadataEditorDialog::MakeRestrictedDrmItemsL(): Interval Start Time");
intervalTime = (TInt64)iDrmInfo->ValueTObjectL<TInt64>( KMPXMediaDrmIntervalStartTime );
}
HBufC* heading = NULL;
HBufC* value = NULL;
// acculated time
if ( expireConstraint == EMPXDrmRightsTypeAccTime )
{
MPX_DEBUG1("CMPXMetadataEditorDialog::MakeRestrictedDrmItemsL(): AccTime based");
heading = StringLoader::LoadLC( R_QTN_DRM_MGR_DET_ACCUM_TIME_LEFT );
TTimeIntervalSeconds accTime = iDrmInfo->ValueTObjectL<TTimeIntervalSeconds>( KMPXMediaDrmAccumulatedTime );
TInt years( 0 );
TInt months( 0 );
TInt days( 0 );
TInt hours( 0 );
TInt minutes( 0 );
TInt seconds( 0 );
SplitTime( accTime, years, months, days, hours, minutes, seconds );
value = AddPartsOfTimeLC( years, months, days, hours, minutes, seconds );
TPtr text = value->Des();
LanguageSpecificNumberConversion( text );
aHeadingsArray->InsertL( aCurrentIndex, heading->Des() );
aDataArray->InsertL( aCurrentIndex, value->Des() );
CleanupStack::PopAndDestroy( value );
CleanupStack::PopAndDestroy( heading );
aCurrentIndex++;
}
// count
if ( expireConstraint == EMPXDrmRightsTypeCount ||
expireConstraint == EMPXDrmRightsTypeTimeCount )
{
MPX_DEBUG1("CMPXMetadataEditorDialog::MakeRestrictedDrmItemsL(): Count based");
heading = StringLoader::LoadLC( R_QTN_DRM_MGR_DET_UTL_X, *aRights );
TInt counts( iDrmInfo->ValueTObjectL<TInt>( KMPXMediaDrmCount ) );
if ( counts == 1 )
{
value = StringLoader::LoadLC( R_QTN_DRM_MGR_DET_1_COUNT );
}
else
{
value = StringLoader::LoadLC(
R_QTN_DRM_MGR_DET_N_COUNTS, counts );
}
TPtr text = value->Des();
LanguageSpecificNumberConversion( text );
aHeadingsArray->InsertL( aCurrentIndex, heading->Des() );
aDataArray->InsertL( aCurrentIndex, value->Des() );
CleanupStack::PopAndDestroy( value );
CleanupStack::PopAndDestroy( heading );
aCurrentIndex++;
}
if ( expireConstraint == EMPXDrmRightsTypeTime ||
expireConstraint == EMPXDrmRightsTypeTimeCount ||
( expireConstraint == EMPXDrmRightsTypeInterval &&
intervalTime > 0 ) )
{
MPX_DEBUG1("CMPXMetadataEditorDialog::MakeRestrictedDrmItemsL(): Time based");
HBufC* dateFormatString = StringLoader::LoadLC(
R_QTN_DATE_USUAL_WITH_ZERO );
HBufC* timeFormatString = StringLoader::LoadLC( R_QTN_TIME_USUAL );
// from
if ( iDrmInfo->IsSupported( KMPXMediaDrmStartTime ) )
{
MPX_DEBUG1("CMPXMetadataEditorDialog::MakeRestrictedDrmItemsL(): Start time found");
TTime from( iDrmInfo->ValueTObjectL<TInt64>( KMPXMediaDrmStartTime ) );
heading = StringLoader::LoadLC( R_QTN_DRM_MGR_DET_RVF_X, *aRights );
HBufC* datePointer = HBufC::NewLC( KMaxFileName );
TPtr date = datePointer->Des();
from.FormatL( date, *dateFormatString );
TBuf<KMPXMaxTimeLength> time;
from.FormatL( time, *timeFormatString );
date.Append( KMPXSpace );
date.Append( time );
LanguageSpecificNumberConversion( date );
aHeadingsArray->InsertL( aCurrentIndex, heading->Des() );
aDataArray->InsertL( aCurrentIndex, date );
CleanupStack::PopAndDestroy( datePointer );
CleanupStack::PopAndDestroy( heading );
aCurrentIndex++;
}
// until
if ( iDrmInfo->IsSupported( KMPXMediaDrmEndTime ) )
{
MPX_DEBUG1("CMPXMetadataEditorDialog::MakeRestrictedDrmItemsL(): End time found");
TTime until( iDrmInfo->ValueTObjectL<TInt64>( KMPXMediaDrmEndTime ) );
heading = StringLoader::LoadLC( R_QTN_DRM_MGR_DET_RVT_X, *aRights );
HBufC* dateToPntr = HBufC::NewLC( KMaxFileName );
TPtr dateTo = dateToPntr->Des();
until.FormatL( dateTo, *dateFormatString );
TBuf<KMPXMaxTimeLength> timeTo;
until.FormatL( timeTo, *timeFormatString );
dateTo.Append( KMPXSpace );
dateTo.Append( timeTo );
LanguageSpecificNumberConversion( dateTo );
aHeadingsArray->InsertL( aCurrentIndex, heading->Des() );
aDataArray->InsertL( aCurrentIndex, dateTo );
CleanupStack::PopAndDestroy( dateToPntr );
CleanupStack::PopAndDestroy( heading );
aCurrentIndex++;
}
CleanupStack::PopAndDestroy( timeFormatString );
CleanupStack::PopAndDestroy( dateFormatString );
}
else if ( expireConstraint == EMPXDrmRightsTypeInterval &&
intervalTime < 0 )
{
MPX_DEBUG1("CMPXMetadataEditorDialog::MakeRestrictedDrmItemsL(): Time not activated");
// times not activated
heading = StringLoader::LoadLC( R_QTN_DRM_MGR_DET_UTS_X, *aRights );
value = StringLoader::LoadLC( R_QTN_DRM_MGR_DET_NOT_ACT );
aHeadingsArray->InsertL( aCurrentIndex, heading->Des() );
aDataArray->InsertL( aCurrentIndex, value->Des() );
CleanupStack::PopAndDestroy( value );
CleanupStack::PopAndDestroy( heading );
aCurrentIndex++;
// query what the current time is
TTime currentTime;
currentTime.HomeTime();
// calculate rights end time
TTimeIntervalSeconds interval = iDrmInfo->ValueTObjectL<TInt64>( KMPXMediaDrmInterval );
TTime endTime( currentTime.Int64() + (TInt64) interval.Int() * KSecondInMicroSeconds );
TBuf<KMPXMaxVal> val;
TInt count = 0;
// years
TTimeIntervalYears years = endTime.YearsFrom( currentTime );
if ( years.Int() )
{
AddSinglePartOfTimeL( years.Int(),
R_QTN_DRM_NBR_OF_YEARS_ONE,
R_QTN_DRM_NBR_OF_YEARS_ONE_FINAL,
R_QTN_DRM_NBR_OF_YEARS_TWO_FOUR,
R_QTN_DRM_NBR_OF_YEARS_FIVE_ZERO,
value );
count++;
val.Append( *value );
endTime -= years;
CleanupStack::PopAndDestroy( value );
}
// months
TTimeIntervalMonths months = endTime.MonthsFrom( currentTime );
if ( months.Int() )
{
AddSinglePartOfTimeL( months.Int(),
R_QTN_DRM_NBR_OF_MONTHS_ONE,
0,
R_QTN_DRM_NBR_OF_MONTHS_TWO_FOUR,
R_QTN_DRM_NBR_OF_MONTHS_FIVE_ZERO,
value );
if ( count )
{
val.Append( KMPXSpace );
}
count++;
val.Append( *value );
endTime -= months;
CleanupStack::PopAndDestroy( value );
}
// days
TTimeIntervalDays days = endTime.DaysFrom( currentTime );
if ( days.Int() && count < 2 )
{
AddSinglePartOfTimeL( days.Int(),
R_QTN_DRM_NBR_OF_DAYS_ONE,
R_QTN_DRM_NBR_OF_DAYS_ONE_FINAL,
R_QTN_DRM_NBR_OF_DAYS_TWO_FOUR,
R_QTN_DRM_NBR_OF_DAYS_FIVE_ZERO,
value );
if ( count )
{
val.Append( KMPXSpace );
}
val.Append( *value );
endTime -= days;
CleanupStack::PopAndDestroy( value );
count++;
}
// hours
TTimeIntervalHours hours;
TInt ret = endTime.HoursFrom( currentTime, hours );
if ( ret == KErrNone && count < 2 && hours.Int() )
{
AddSinglePartOfTimeL( hours.Int(),
R_QTN_DRM_NBR_OF_HOURS_ONE,
R_QTN_DRM_NBR_OF_HOURS_ONE_FINAL,
R_QTN_DRM_NBR_OF_HOURS_TWO_FOUR,
R_QTN_DRM_NBR_OF_HOURS_FIVE_ZERO,
value );
if ( count )
{
val.Append( KMPXSpace );
}
val.Append( *value );
endTime -= hours;
CleanupStack::PopAndDestroy( value );
count++;
}
// mins
TTimeIntervalMinutes minutes;
ret = endTime.MinutesFrom( currentTime, minutes );
if ( ret == KErrNone && count < 2 && minutes.Int() )
{
AddSinglePartOfTimeL( minutes.Int(),
R_QTN_DRM_NBR_OF_MINS_ONE,
R_QTN_DRM_NBR_OF_MINS_ONE_FINAL,
R_QTN_DRM_NBR_OF_MINS_TWO_FOUR,
R_QTN_DRM_NBR_OF_MINS_FIVE_ZERO,
value );
if ( count )
{
val.Append( KMPXSpace );
}
val.Append( *value );
endTime -= minutes;
CleanupStack::PopAndDestroy( value );
count++;
}
// seconds
TTimeIntervalSeconds seconds;
ret = endTime.SecondsFrom( currentTime,seconds );
if ( ret == KErrNone && count < 2 && seconds.Int() )
{
AddSinglePartOfTimeL( seconds.Int(),
R_QTN_DRM_NBR_OF_SECS_ONE,
R_QTN_DRM_NBR_OF_SECS_ONE_FINAL,
R_QTN_DRM_NBR_OF_SECS_TWO_FOUR,
R_QTN_DRM_NBR_OF_SECS_FIVE_ZERO,
value );
if ( count )
{
val.Append( KMPXSpace );
}
val.Append( *value );
CleanupStack::PopAndDestroy(); // value
count++;
}
heading = StringLoader::LoadLC( R_QTN_DRM_MGR_DET_UDL_X, *aRights );
LanguageSpecificNumberConversion( val );
aHeadingsArray->InsertL( aCurrentIndex, heading->Des() );
aDataArray->InsertL( aCurrentIndex, val );
CleanupStack::PopAndDestroy( heading );
aCurrentIndex++;
}
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::AddPartsOfTimeLC
// -----------------------------------------------------------------------------
//
HBufC* CMPXMetadataEditorDialog::AddPartsOfTimeLC( TInt aIntYrs, TInt aIntMon, TInt aIntDay,
TInt aIntHrs, TInt aIntMin, TInt aIntSec )
{
MPX_FUNC( "CMPXMetadataEditorDialog::AddPartsOfTimeLC" );
// Only the two most meaningful data will be showed
TInt numOfData( 0 );
const TInt KMaxDataItems = 2;
CDesCArrayFlat* strings = new ( ELeave ) CDesCArrayFlat( KMaxDataItems );
CleanupStack::PushL( strings );
if ( aIntYrs > 0 )
{
AddSinglePartOfTimeL( aIntYrs,
R_QTN_DRM_NBR_OF_YEARS_ONE,
R_QTN_DRM_NBR_OF_YEARS_ONE_FINAL,
R_QTN_DRM_NBR_OF_YEARS_TWO_FOUR,
R_QTN_DRM_NBR_OF_YEARS_FIVE_ZERO,
strings );
numOfData++;
}
if ( aIntMon > 0 )
{
// Second type not provided because 11 is the maximum
AddSinglePartOfTimeL( aIntMon,
R_QTN_DRM_NBR_OF_MONTHS_ONE,
0,
R_QTN_DRM_NBR_OF_MONTHS_TWO_FOUR,
R_QTN_DRM_NBR_OF_MONTHS_FIVE_ZERO,
strings );
numOfData++;
}
// Only if years or months were missing
if ( aIntDay > 0 && numOfData < KMaxDataItems )
{
AddSinglePartOfTimeL( aIntDay,
R_QTN_DRM_NBR_OF_DAYS_ONE,
R_QTN_DRM_NBR_OF_DAYS_ONE_FINAL,
R_QTN_DRM_NBR_OF_DAYS_TWO_FOUR,
R_QTN_DRM_NBR_OF_DAYS_FIVE_ZERO,
strings );
numOfData++;
}
if ( aIntHrs > 0 && numOfData < KMaxDataItems )
{
AddSinglePartOfTimeL( aIntHrs,
R_QTN_DRM_NBR_OF_HOURS_ONE,
R_QTN_DRM_NBR_OF_HOURS_ONE_FINAL,
R_QTN_DRM_NBR_OF_HOURS_TWO_FOUR,
R_QTN_DRM_NBR_OF_HOURS_FIVE_ZERO,
strings );
numOfData++;
}
if ( aIntMin > 0 && numOfData < KMaxDataItems )
{
AddSinglePartOfTimeL( aIntMin,
R_QTN_DRM_NBR_OF_MINS_ONE,
R_QTN_DRM_NBR_OF_MINS_ONE_FINAL,
R_QTN_DRM_NBR_OF_MINS_TWO_FOUR,
R_QTN_DRM_NBR_OF_MINS_FIVE_ZERO,
strings );
numOfData++;
}
// If interval is 0, then it shows "0 seconds" anyway
if ( ( aIntSec > 0 && numOfData < KMaxDataItems ) || numOfData == 0 )
{
AddSinglePartOfTimeL( aIntSec,
R_QTN_DRM_NBR_OF_SECS_ONE,
R_QTN_DRM_NBR_OF_SECS_ONE_FINAL,
R_QTN_DRM_NBR_OF_SECS_TWO_FOUR,
R_QTN_DRM_NBR_OF_SECS_FIVE_ZERO,
strings );
numOfData++;
}
HBufC* stringHolder = NULL;
if ( numOfData == 1 )
{
stringHolder = StringLoader::LoadL( R_QTN_DRM_MGR_DET_INTER,
strings->MdcaPoint(0) );
}
else
{
stringHolder = StringLoader::LoadL( R_QTN_DRM_MGR_DET_INTER_TWO,
*strings );
}
CleanupStack::PopAndDestroy( strings );
CleanupStack::PushL( stringHolder );
return stringHolder;
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::AddSinglePartOfTimeL
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::AddSinglePartOfTimeL( TInt aNumOfElements,
TInt aResourceIdSingle,
TInt aResourceIdOneFinal,
TInt aResourceIdTwoFour,
TInt aResourceIdFiveZero,
CDesCArrayFlat* aStrings )
{
MPX_FUNC( "CMPXMetadataEditorDialog::AddSinglePartOfTimeL" );
HBufC* stringHolder = NULL;
TInt finalOneDigit( aNumOfElements % KDigitTen );
TInt finalTwoDigits( aNumOfElements % KDigitHundred );
if ( aNumOfElements == 1 )
{
stringHolder = StringLoader::LoadLC( aResourceIdSingle );
}
else if ( finalOneDigit == 1 && finalTwoDigits != KDigitEleven )
{
stringHolder = StringLoader::LoadLC( aResourceIdOneFinal,
aNumOfElements );
}
else if ( finalOneDigit == 0 ||
( finalOneDigit >= KDigitFive && finalOneDigit <= KDigitNine ) ||
( finalTwoDigits >= KDigitEleven && finalTwoDigits <= KDigitFourTeen ) )
{
stringHolder = StringLoader::LoadLC( aResourceIdFiveZero,
aNumOfElements );
}
else
{
stringHolder = StringLoader::LoadLC( aResourceIdTwoFour,
aNumOfElements );
}
if ( aStrings )
{
aStrings->AppendL( *stringHolder );
}
CleanupStack::PopAndDestroy ( stringHolder );
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::SplitTime
//
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::SplitTime( const TTimeIntervalSeconds& aInterval,
TInt& aIntYrs, TInt& aIntMon, TInt& aIntDay,
TInt& aIntHrs, TInt& aIntMin, TInt& aIntSec )
{
MPX_FUNC( "CMPXMetadataEditorDialog::SplitTime" );
const TInt KSecsInMin( 60 );
const TInt KSecsInHour( KSecsInMin * 60 );
const TInt KSecsInDay( KSecsInHour * 24 );
// includes leap year day
const TInt KMaxDaysInMonths[] = {
KMaxDaysInOneMonths,
KMaxDaysInTwoMonths,
KMaxDaysInThreeMonths,
KMaxDaysInFourMonths,
KMaxDaysInFiveMonths,
KMaxDaysInSixMonths,
KMaxDaysInSevenMonths,
KMaxDaysInEightMonths,
KMaxDaysInNineMonths,
KMaxDaysInTenMonths,
KMaxDaysInElevenMonths,
KMaxDaysInEightMonths };
// calculate full days
TInt temp( aInterval.Int() / KSecsInDay );
// calculate full years, calculate without leap year for user to get the
// longest time possible
aIntYrs = temp / ( KMaxDaysInMonths[KDigitEleven] - 1 );
// calc remainder days
temp = temp % ( KMaxDaysInMonths[KDigitEleven] - 1 );
aIntMon = 0;
TInt i( 0 );
if ( temp >= KMaxDaysInMonths[0] )
{
for ( i = 0; i < KDigitEleven; i++ )
{
// found correct amount of months
if ( temp >= KMaxDaysInMonths[i] && temp < KMaxDaysInMonths[i+1] )
{
// i now contains amount of full months (+1 because of table index)
aIntMon = i + 1;
break;
}
}
}
// calc remainder days = allSecs - secsInFullYears - secsInFullMonts
if( temp >= KMaxDaysInMonths[i] )
{
aIntDay = temp - KMaxDaysInMonths[i];
}
else
{
aIntDay = temp;
}
// calculate remainder secs
temp = aInterval.Int() % KSecsInDay;
aIntHrs = temp / KSecsInHour;
// calculate remainder secs
temp = temp % KSecsInHour;
aIntMin = temp / KSecsInMin;
// calculate remainder secs
aIntSec = temp % KSecsInMin;
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::AddSinglePartOfTimeL
// Language specific time formats
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::AddSinglePartOfTimeL(
TInt aNumOfElements,
TInt aResourceIdSingle,
TInt aResourceIdOneFinal,
TInt aResourceIdTwoFour,
TInt aResourceIdFiveZero,
HBufC*& aStrings )
{
MPX_FUNC( "CMPXMetadataEditorDialog::AddSinglePartOfTimeL" );
TInt finalOneDigit = aNumOfElements % KMPXOneDigit;
TInt finalTwoDigits = aNumOfElements % KMPXTwoDigits;
if ( aNumOfElements == 1 )
{
aStrings = StringLoader::LoadLC( aResourceIdSingle );
}
else if ( finalOneDigit == 1 && finalTwoDigits != KDigitEleven )
{
// Used for period of years ending with 1 from 21 (21, 31, 41, etc.)
aStrings = StringLoader::LoadLC( aResourceIdOneFinal, aNumOfElements );
}
else if ( finalOneDigit == 0 ||
( finalOneDigit >= KDigitFive && finalOneDigit <= KDigitNine ) ||
( finalTwoDigits >= KDigitEleven && finalTwoDigits <= KDigitFourTeen ) )
{
// Used for period of minutes ending from 5 to 0 plus range between 11
// and 14 (5-20, 25-30, 35-40, 45-50, 53-59)
aStrings = StringLoader::LoadLC( aResourceIdFiveZero, aNumOfElements );
}
else
{
// Used for period of minutes ending from 2 to 4, excluded 12-14 (2-4,
// 22-24, 32-34, 42-44, 52-54)
aStrings = StringLoader::LoadLC( aResourceIdTwoFour, aNumOfElements );
}
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::LanguageSpecificNumberConversion
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::LanguageSpecificNumberConversion( TDes& aText ) const
{
MPX_FUNC( "CMPXMetadataEditorDialog::LanguageSpecificNumberConversion" );
if ( AknTextUtils::DigitModeQuery( AknTextUtils::EDigitModeShownToUser ) )
{
AknTextUtils::DisplayTextLanguageSpecificNumberConversion( aText );
}
}
// ----------------------------------------------------------------------------
// Converts the time value to localtime
// ----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::ConvertToLocalTimeL(TTime& aTime )
{
RTz timeConverter;
CleanupClosePushL(timeConverter);
User::LeaveIfError( timeConverter.Connect() );
User::LeaveIfError( timeConverter.ConvertToLocalTime( aTime ) );
CleanupStack::PopAndDestroy();
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::AddItemToListBoxL
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::AddItemToListBoxL(
const TDesC& aHeading,
const TDesC& aValue,
CDesCArray* aItemArray )
{
MPX_FUNC( "CMPXMetadataEditorDialog::AddItemToListBoxL" );
CDesCArrayFlat* items = new (ELeave) CDesCArrayFlat( 2 );
CleanupStack::PushL( items );
items->AppendL( aHeading ); //First string (heading)
items->AppendL( aValue ); //Second string (value)
HBufC* headingAndValue =
StringLoader::LoadLC( R_MPX_CUI_METADATAEDITOR_FILE_DETAILS_ROW_FORMAT, *items );
aItemArray->AppendL( *headingAndValue );
CleanupStack::PopAndDestroy( headingAndValue );
CleanupStack::PopAndDestroy( items );
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::HandleControlStateChangeL
// Handle State Changes in Genre popup.
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::HandleControlStateChangeL( TInt aControlId )
{
MPX_FUNC( "CMPXMetadataEditorDialog::HandleControlStateChangeL" );
if( !iTryingExit )
{
if ( aControlId == EMPXMetadataEditorDlgCtrlIdGenre )
{
// check to see if the genre pop has item custom selected
if ( iTextValues->CurrentValueIndex() == 0 )
{
HBufC* genreName = HBufC::NewLC( KMPXSongDetailsTextMaxLen );
TPtr genrePtr = genreName->Des();
CAknTextQueryDialog* queryDlg =
CAknTextQueryDialog::NewL( genrePtr );
CleanupStack::PushL( queryDlg );
HBufC* promptTxt = NULL;
if ( iCurrentLibrary == EMPXMetadataEditorDlgCollection )
{
promptTxt = StringLoader::LoadLC( R_MPX_CUI_CUSTOM_GENRE_RENAME_TEXT );
}
else
{
promptTxt = StringLoader::LoadLC( R_MPX_CUI_CUSTOM_CATEGORY_RENAME_TEXT );
}
queryDlg->SetPromptL( *promptTxt );
queryDlg->SetPredictiveTextInputPermitted( ETrue );
CleanupStack::PopAndDestroy( promptTxt );
CleanupStack::Pop( queryDlg );
if ( queryDlg->ExecuteLD( R_MPX_CUI_CUSTOM_GENRE_NAME_QUERY_DLG ) )
{
TBool isHandled = EFalse;
TBool tryExit = EFalse;
if ( iCurrentLibrary == EMPXMetadataEditorDlgCollection )
{
// in music libray, if genre is set to podcast, ask user
// to confirm move to podcast database
HBufC* podcastText = StringLoader::LoadLC( R_MPX_QTN_NMP_GENRE_PODCAST );
if ( genreName->Des().CompareF( *podcastText ) == 0 &&
!iDisablePodcasting )
{
isHandled = ETrue;
// genre is set to podcast
if ( PromptForLibraryChangeL( EMPXMetadataEditorDlgPodcast ) )
{
MPX_DEBUG1( "CMPXMetadataEditorDialog::HandleControlStateChangeL Move to a different library" );
iCollectionUiHelper->MoveL( iMedia, TUid::Uid(EMPXCollectionPluginPodCast) , this);
tryExit = ETrue;
iTryingExit = ETrue;
}
}
CleanupStack::PopAndDestroy( podcastText );
}
if ( !isHandled )
{
// ok selected
CMPXMedia* media = CMPXMedia::NewL();
CleanupStack::PushL( media );
iMedia->SetTextValueL(
KMPXMediaMusicGenre, genreName->Des() );
media->SetTextValueL(
KMPXMediaMusicGenre, genreName->Des() );
SaveMediaPropertiesL( media );
CleanupStack::PopAndDestroy( media );
}
if ( !tryExit )
{
FetchGenreL();
}
}
else
{
// Text query cancelled. Display popup list again.
iPopup->ActivateSelectionListL();
// reset to original index
TInt genreIndex;
iGenreArr->Find( iMedia->ValueText( KMPXMediaMusicGenre ), genreIndex );
iTextValues->SetCurrentValueIndex( genreIndex );
}
CleanupStack::PopAndDestroy( genreName );
}
else
{
if ( iUnknownGenre &&
( iTextValues->CurrentValueIndex() == ( iTextValues->MdcArray()->MdcaCount() - 1 ) ) )
{
MPX_DEBUG1( "CMPXMetadataEditorDialog::HandleControlStateChangeL last entry with unknown genre, do nothing" );
}
else
{
CMPXMedia* media = CMPXMedia::NewL();
CleanupStack::PushL( media );
HBufC* currentTxt = iTextValues->CurrentValueTextLC();
iMedia->SetTextValueL( KMPXMediaMusicGenre, *currentTxt );
media->SetTextValueL( KMPXMediaMusicGenre, *currentTxt );
CleanupStack::PopAndDestroy( currentTxt );
SaveMediaPropertiesL( media );
CleanupStack::PopAndDestroy( media );
FetchGenreL();
}
}
}
else if ( aControlId == EMPXMetadataEditorDlgCtrlIdLibrary )
{
TInt currentIndex = iLibraryTextValues->CurrentValueIndex();
if ( iCurrentLibrary != currentIndex )
{
if ( PromptForLibraryChangeL( currentIndex ) )
{
MPX_DEBUG1( "CMPXMetadataEditorDialog::HandleControlStateChangeL Move to a different library" );
TUid targetCollection = TUid::Uid( EMPXCollectionPluginMusic );
if ( currentIndex == EMPXMetadataEditorDlgPodcast )
{
targetCollection = TUid::Uid(EMPXCollectionPluginPodCast);
}
// before moving, save current data
SaveFormDataL();
iCurrentLibrary = currentIndex; // Fix for ELWG-7AACMS prevent the if clause to be reentried.
iCollectionUiHelper->MoveL( iMedia, targetCollection, this );
iTryingExit = ETrue;
}
else
{
iLibraryTextValues->SetCurrentValueIndex( iCurrentLibrary );
// Fix EIZU-7QQAZN, Let it display back to "Music" immediately.
if ( IdOfFocusControl() == EMPXMetadataEditorDlgCtrlIdLibrary )
{
iPopup = static_cast<CAknPopupField*>
( ControlOrNull( EMPXMetadataEditorDlgCtrlIdLibrary ) );
if ( iPopup )
{
iPopup->SetQueryValueL( iLibraryTextValues );
iPopup->DrawDeferred();
}
}
}
}
}
}
CAknForm::HandleControlStateChangeL( aControlId );
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::PrepareForFocusTransitionL
// Handle Focus changes for track and year controls.
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::PrepareForFocusTransitionL()
{
MPX_FUNC( "CMPXMetadataEditorDialog::PrepareForFocusTransitionL" );
CAknForm::PrepareForFocusTransitionL();
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::GetHelpContext
// Gets Help
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::GetHelpContext(
TCoeHelpContext& aContext ) const
{
MPX_FUNC( "CMPXMetadataEditorDialog::GetHelpContext" );
aContext.iMajor = KAppUidMusicPlayerX;
aContext.iContext = KMUS_HLP_METADATA_EDITING;
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::HandleFindAllL
// Handle callback for "find" operation
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::HandleFindAllL(const CMPXMedia& aResults,
TBool /*aComplete*/, TInt aError)
{
MPX_FUNC( "CMPXMetadataEditorDialog::HandleFindAllL" );
iPopup = static_cast<CAknPopupField*>
( ControlOrNull( EMPXMetadataEditorDlgCtrlIdGenre ) );
CleanUpGenreText();
// populate predefined genre
TResourceReader reader;
if ( iCurrentLibrary == EMPXMetadataEditorDlgCollection )
{
if( !iDisablePodcasting )
{
iEikonEnv->CreateResourceReaderLC( reader, R_MPX_MUSIC_GENRE_STRINGS );
}
else
{
iEikonEnv->CreateResourceReaderLC( reader, R_MPX_MUSIC_GENRE_STRINGS_PODCAST );
}
}
else if ( iCurrentLibrary == EMPXMetadataEditorDlgPodcast )
{
iEikonEnv->CreateResourceReaderLC(
reader, R_MPX_PODCAST_CATEGORY_STRINGS );
}
iGenreArr = reader.ReadDesCArrayL( );
CleanupStack::PopAndDestroy(); // reader
// populate genres from database
if ( aError == KErrNone )
{
const CMPXMediaArray* mediaArray =
aResults.Value<CMPXMediaArray>( KMPXMediaArrayContents );
User::LeaveIfNull(const_cast<CMPXMediaArray*>(mediaArray));
TInt entriesCount( mediaArray->Count() );
MPX_DEBUG2( "CMPXMetadataEditorDialog::HandleFindAllL genres from database count = %d", entriesCount );
for ( TInt i = 0; i < entriesCount; i++ )
{
CMPXMedia* media = mediaArray->AtL( i );
TInt location( 0 );
const TDesC& genre = media->ValueText( KMPXMediaGeneralTitle );
if ( i == entriesCount - 1)
{
if ( genre.Compare( KNullDesC ) != 0 )
{
// if last item is a null descriptor, don't append to array
if ( iGenreArr->Find( genre, location ) != 0 )
{
// a match is not found
MPX_DEBUG1( "CMPXMetadataEditorDialog::HandleFindAllL adding to genre list" );
iGenreArr->AppendL( genre );
}
}
}
else
{
if ( iGenreArr->Find( genre, location ) != 0 )
{
// a match is not found
MPX_DEBUG1( "CMPXMetadataEditorDialog::HandleFindAllL adding to genre list" );
iGenreArr->AppendL( genre );
}
}
}
}
iGenreArr->Sort(ECmpCollated);
if ( iCurrentLibrary == EMPXMetadataEditorDlgCollection )
{
HBufC* custTxt =
StringLoader::LoadLC( R_MPX_CUI_CUSTOM_GENRE_PROMPT_TEXT );
iGenreArr->InsertL( 0, *custTxt );
CleanupStack::PopAndDestroy( custTxt );
}
else if ( iCurrentLibrary == EMPXMetadataEditorDlgPodcast )
{
HBufC* custTxt =
StringLoader::LoadLC( R_MPX_CUI_PODCAST_CUSTOM_GENRE_PROMPT_TEXT );
iGenreArr->InsertL( 0, *custTxt );
CleanupStack::PopAndDestroy( custTxt );
}
iValueTextArray = CAknQueryValueTextArray::NewL();
iValueTextArray->SetArray( *iGenreArr );
iTextValues = CAknQueryValueText::NewL();
iTextValues->SetArrayL( iValueTextArray );
if ( iMedia->ValueText( KMPXMediaMusicGenre ).Length() == 0 )
{
// no genre
iUnknownGenre = ETrue;
HBufC* unknownGenre( StringLoader::LoadLC( R_MPX_CUI_UNKNOWN_GENRE_TEXT ) );
iGenreArr->AppendL( *unknownGenre );
CleanupStack::PopAndDestroy( unknownGenre );
iTextValues->SetCurrentValueIndex( iGenreArr->Count() - 1 );
}
else
{
// Find the genre
iUnknownGenre = EFalse;
TInt genreIndex;
iGenreArr->Find( iMedia->ValueText( KMPXMediaMusicGenre ), genreIndex );
iTextValues->SetCurrentValueIndex( genreIndex );
}
// Set values into popup fields.
iPopup->SetQueryValueL( iTextValues ); // Moved up from below.
iPopup->DrawDeferred();
}
// ----------------------------------------------------------------------------
// void CMPXMetadataEditorDialog::HandleOperationCompleteL
// Handle callback for the ui helper.
// ----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::HandleOperationCompleteL(
TCHelperOperation aOperation,
TInt aErr, void* aArgument )
{
MPX_FUNC( "CMPXMetadataEditorDialog::HandleOperationCompleteL" );
if ( aOperation == EMoveOp )
{
if ( aErr != KErrNone )
{
// TO-DO: error handling
}
// move complete, quit the editor
if ( iIdle )
{
iIdle->Cancel();
delete iIdle;
iIdle = NULL;
}
iIdle = CIdle::NewL( CActive::EPriorityStandard );
iIdle->Start( TCallBack( CMPXMetadataEditorDialog::DeferredExitCallback, this ) );
}
if ( aArgument )
{
delete (CBase*)aArgument;
}
}
// ----------------------------------------------------------------------------
// void CMPXMetadataEditorDialog::DeferredExitCallback
// call back function for deferred exit.
// ----------------------------------------------------------------------------
//
TInt CMPXMetadataEditorDialog::DeferredExitCallback( TAny* aPtr )
{
MPX_FUNC( "CMPXMetadataEditorDialog::DeferredExitCallback" );
CMPXMetadataEditorDialog* self =
static_cast<CMPXMetadataEditorDialog*>( aPtr );
TRAP_IGNORE( self->TryExitL( EAknSoftkeyExit ) );
return KErrNone;
}
// ----------------------------------------------------------------------------
// void CMPXMetadataEditorDialog::DeferredFileDetailsCallback
// call back function for deferred file details dialog.
// ----------------------------------------------------------------------------
//
TInt CMPXMetadataEditorDialog::DeferredFileDetailsCallback( TAny* aPtr )
{
MPX_FUNC( "CMPXMetadataEditorDialog::DeferredFileDetailsCallback" );
CMPXMetadataEditorDialog* self =
static_cast<CMPXMetadataEditorDialog*>( aPtr );
TRAP_IGNORE( self->ViewFileDetailsPopupL() );
return KErrNone;
}
#ifdef __ENABLE_MSK
// -----------------------------------------------------------------------------
// CMPXAddTracksDialog::UpdateSoftkeyL()
// Update softkey.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::UpdateSoftkeyL()
{
MPX_FUNC( "CMPXMetadataEditorDialog::UpdateSoftkeyL" );
TInt resId( 0 );
if ( ( IdOfFocusControl() == EMPXMetadataEditorDlgCtrlIdGenre ) ||
( IdOfFocusControl() == EMPXMetadataEditorDlgCtrlIdLibrary ) )
{
resId = R_MPX_CUI_SONG_DETAILS_SOFTKEYS_OPTIONS_CHANGE_DONE;
}
else
{
resId = R_MPX_CUI_SONG_DETAILS_SOFTKEYS_OPTIONS_EMPTY_BACK;
}
ButtonGroupContainer().SetCommandSetL( resId );
ButtonGroupContainer().DrawDeferred();
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::OfferKeyEventL
// Handles key-events.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TKeyResponse CMPXMetadataEditorDialog::OfferKeyEventL(
const TKeyEvent& aKeyEvent,
TEventCode aType )
{
MPX_FUNC( "CMPXMetadataEditorDialog::OfferKeyEventL" );
TKeyResponse res = CAknForm::OfferKeyEventL( aKeyEvent, aType );
if ( aType == EEventKey )
{
if (aKeyEvent.iScanCode && (aKeyEvent.iScanCode == EStdKeyUpArrow
|| aKeyEvent.iScanCode == EStdKeyDownArrow))
{
UpdateSoftkeyL();
}
else if ((aKeyEvent.iCode == EKeyOK || aKeyEvent.iCode == EKeyEnter)
&& (IdOfFocusControl() == EMPXMetadataEditorDlgCtrlIdDRMDetail))
{
LaunchDrmInfoL();
}
}
return res;
}
#endif // __ENABLE_MSK
// ----------------------------------------------------------------------------
// void CMPXMetadataEditorDialog::PreLayoutDynInitL
// Initialises the dialog's controls before the dialog is sized and layed out.
// ----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::PreLayoutDynInitL()
{
MPX_FUNC( "CMPXMetadataEditorDialog::PreLayoutDynInitL" );
SetTitlePaneL();
SetNaviLabelL();
// Get media property for the current song
if ( iParam ) // Dialog launched from CollectionView
{
CMPXCollectionPath* cpath = iCollectionUtility->Collection().PathL();
CleanupStack::PushL( cpath );
TLex yearLex( iParam->Des() );
TInt lexToInt = NULL;
if ( yearLex.Val( lexToInt ) == KErrNone )
{
cpath->Set( lexToInt );
RArray<TMPXAttribute> attrs;
CleanupClosePushL(attrs);
attrs.Append( KMPXMediaGeneralAll );
attrs.Append( KMPXMediaAudioAudioAll );
attrs.Append( KMPXMediaMusicAll );
attrs.Append( KMPXMediaDrmProtected );
if ( iCurrentLibrary == EMPXMetadataEditorDlgPodcast )
{
attrs.Append(
TMPXAttribute( KMPXMediaIdPodcast, EMPXMediaPodcastAll ) );
}
iCurrentMediaLOp = EMPXMetadataEditorGetSongInfo;
iCollectionUtility->Collection().MediaL( *cpath, attrs.Array() );
CleanupStack::PopAndDestroy( &attrs );
}
CleanupStack::PopAndDestroy( cpath );
}
else // Dialog launched from NowPlayingView
{
// Get the playback utility instance from engine.
iPlaybackUtility = MMPXPlaybackUtility::UtilityL( KPbModeDefault );
MMPXSource* s = iPlaybackUtility->Source();
if ( s )
{
RArray<TMPXAttribute> attrs;
CleanupClosePushL(attrs);
attrs.Append( KMPXMediaGeneralAll );
attrs.Append( KMPXMediaAudioAudioAll );
attrs.Append( KMPXMediaMusicAll );
attrs.Append( KMPXMediaDrmProtected );
if ( iCurrentLibrary == EMPXMetadataEditorDlgPodcast )
{
attrs.Append(
TMPXAttribute( KMPXMediaIdPodcast, EMPXMediaPodcastAll ) );
}
iCurrentMediaLOp = EMPXMetadataEditorGetSongInfo;
s->MediaL(attrs.Array(), *this);
CleanupStack::PopAndDestroy( &attrs );
}
}
// Podcasting is enabled
if ( !iDisablePodcasting )
{
iPopup = static_cast<CAknPopupField*>
( ControlOrNull( EMPXMetadataEditorDlgCtrlIdLibrary ) );
iLibraryArr = new (ELeave) CDesCArrayFlat( 1 );
HBufC* custTxt = StringLoader::LoadLC( R_MPX_CUI_GENRE_SELECTION_MUSIC_TEXT );
iLibraryArr->AppendL( *custTxt );
CleanupStack::PopAndDestroy( custTxt );
custTxt = StringLoader::LoadLC( R_MPX_CUI_GENRE_SELECTION_PODCAST_TEXT );
iLibraryArr->AppendL( *custTxt );
CleanupStack::PopAndDestroy( custTxt );
iLibraryValueTextArray = CAknQueryValueTextArray::NewL();
iLibraryValueTextArray->SetArray( *iLibraryArr );
iLibraryTextValues = CAknQueryValueText::NewL();
iLibraryTextValues->SetArrayL( iLibraryValueTextArray );
iLibraryTextValues->SetCurrentValueIndex( iCurrentLibrary );
// Set values into popup fields
iPopup->SetQueryValueL( iLibraryTextValues ); // Moved up from below
}
}
// ----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::PostLayoutDynInitL
// Set default field value to member data.
// ----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::PostLayoutDynInitL()
{
MPX_FUNC( "CMPXMetadataEditorDialog::PostLayoutDynInitL" );
CAknForm::PostLayoutDynInitL();
SetEditableL( EFalse );
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::SaveMediaPropertiesL
// Saves media back to collection engine
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::SaveMediaPropertiesL( CMPXMedia* aMedia )
{
MPX_FUNC( "CMPXMetadataEditorDialog::SaveMediaPropertiesL" );
if ( iMedia->IsSupported( KMPXMediaGeneralUri ) )
{
aMedia->SetTextValueL(
KMPXMediaGeneralUri, iMedia->ValueText( KMPXMediaGeneralUri ) );
}
if ( iMedia->IsSupported( KMPXMediaGeneralType ) )
{
aMedia->SetTObjectValueL<TInt>(
KMPXMediaGeneralType, iMedia->ValueTObjectL<TInt>( KMPXMediaGeneralType ) );
}
if ( iMedia->IsSupported( KMPXMediaGeneralCategory ) )
{
aMedia->SetTObjectValueL<TInt>(
KMPXMediaGeneralCategory,
iMedia->ValueTObjectL<TInt>( KMPXMediaGeneralCategory ) );
}
if ( iMedia->IsSupported( KMPXMediaGeneralId ) )
{
aMedia->SetTObjectValueL<TMPXItemId>(
KMPXMediaGeneralId, iMedia->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ) );
}
if ( iMedia->IsSupported( KMPXMediaGeneralCollectionId ) )
{
aMedia->SetTObjectValueL<TUid>(
KMPXMediaGeneralCollectionId,
iMedia->ValueTObjectL<TUid>( KMPXMediaGeneralCollectionId ) );
}
if ( iMedia->IsSupported( KMPXMediaMusicAlbumArtFileName ) )
{
aMedia->SetTextValueL(
KMPXMediaMusicAlbumArtFileName,
iMedia->ValueText( KMPXMediaMusicAlbumArtFileName ) );
}
// toggle the modified flag for the internal media reference
// or else any subsequent FindAllL calls won't be able to
// match against this object
iMedia->SetTObjectValueL<TBool>(KMPXMediaGeneralModified, ETrue);
// Set to collection via command
//
CMPXCommand* cmd = CMPXCommand::NewL();
CleanupStack::PushL( cmd );
cmd->SetTObjectValueL( KMPXCommandGeneralId, KMPXCommandIdCollectionSet );
cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue );
TUid colId(iMedia->ValueTObjectL<TUid>(KMPXMediaGeneralCollectionId));
cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, colId.iUid );
cmd->SetCObjectValueL<CMPXMedia>( KMPXCommandColSetMedia, aMedia );
iCollectionUtility->Collection().CommandL( *cmd );
CleanupStack::PopAndDestroy( cmd );
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::AppendStringToArrayL
// Appends the value to the array, if the vaule has zero length,
// appends "unavailable"
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::AppendStringToArrayL(
CDesCArrayFlat* aArray, const TDesC& aValue )
{
MPX_FUNC( "CMPXMetadataEditorDialog::AppendStringToArrayL" );
if ( aValue.Length() > 0 )
{
HBufC* stringBuf = HBufC::NewLC(
aValue.Length() + KMPXFileDetailsExtraBufferLen );
TPtr stringBufPtr = stringBuf->Des();
stringBufPtr.Append( aValue );
aArray->AppendL( stringBufPtr );
CleanupStack::PopAndDestroy( stringBuf );
}
else
{
aArray->AppendL( KNullDesC );
}
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::SetControlTextL
// Sets control text
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::SetControlTextL( TInt aControlId,
const TDesC& aValue, const TDesC& aAlternateValue )
{
MPX_FUNC( "CMPXMetadataEditorDialog::SetControlTextL" );
CEikEdwin* myEdwin = static_cast< CEikEdwin* >
( ControlOrNull( aControlId ) );
if ( myEdwin )
{
if ( aValue.Length() > 0 )
{
myEdwin->SetTextL( &( aValue ) );
}
else if ( aAlternateValue.Length() > 0 )
{
myEdwin->SetTextL( &( aAlternateValue ) );
}
}
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::SetControlNumberL
// Sets control number
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::SetControlNumberL( TInt aControlId,
const TDesC& aValue, TInt aMinValue, TInt aMaxValue )
{
MPX_FUNC( "CMPXMetadataEditorDialog::SetControlNumberL" );
CEikEdwin* myEdwin = static_cast< CEikEdwin* >
( ControlOrNull( aControlId ) );
if ( myEdwin )
{
if ( aValue.Length() > 0 )
{
TLex numLex( aValue );
TInt LexToInt;
if ( numLex.Val( LexToInt ) == KErrNone )
{
if ( LexToInt > aMaxValue )
{
LexToInt = aMaxValue;
}
if ( LexToInt < aMinValue )
{
LexToInt = aMinValue;
}
TBuf<KMPXSongDetailsNumTextWidth> num;
num.AppendNum( LexToInt );
myEdwin->SetTextL( &num );
}
}
}
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::PromptForLibraryChangeL
// prompt user for library change
// -----------------------------------------------------------------------------
//
TBool CMPXMetadataEditorDialog::PromptForLibraryChangeL( TInt aMoveToLibrary )
{
MPX_FUNC( "CMPXMetadataEditorDialog::PromptForLibraryChangeL" );
CMPXQueryDialog* confirmationDlg = CMPXQueryDialog::NewL();
CleanupStack::PushL( confirmationDlg );
HBufC* libraryName = NULL;
if ( aMoveToLibrary == EMPXMetadataEditorDlgCollection )
{
libraryName =
StringLoader::LoadLC( R_MPX_CUI_GENRE_SELECTION_MUSIC_TEXT );
}
else if ( aMoveToLibrary == EMPXMetadataEditorDlgPodcast )
{
libraryName =
StringLoader::LoadLC( R_MPX_CUI_GENRE_SELECTION_PODCAST_TEXT );
}
else
{
// should not reach here
User::Leave( KErrArgument );
}
HBufC* promptTxt = StringLoader::LoadLC(
R_MPX_CUI_QUERY_MOVE_TO_LIBRARY, libraryName->Des() );
confirmationDlg->SetPromptL( *promptTxt );
CleanupStack::PopAndDestroy( promptTxt );
confirmationDlg->PublishDialogL(
EMPlayerQueryMoveToLibrary,
KMPlayerNoteCategory);
CAknMediatorFacade* covercl(
AknMediatorFacade( confirmationDlg ) );
if ( covercl )
{
covercl->BufStream() << libraryName->Des();
}
CleanupStack::PopAndDestroy( libraryName );
CleanupStack::Pop( confirmationDlg );
return confirmationDlg->ExecuteLD( R_MPX_CUI_MOVE_TO_LIBRARY_CONFIRMATION_QUERY );
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::UpdateMediaObjectWithControlL
// Updates media object with current control text, this will also
// update iMedia
// -----------------------------------------------------------------------------
//
TBool CMPXMetadataEditorDialog::UpdateMediaObjectWithControlL(
TInt aControlId, CMPXMedia* aMedia, TMPXAttribute aAttribute )
{
MPX_FUNC( "CMPXMetadataEditorDialog::UpdateMediaObjectWithControlL" );
TBool ret = EFalse;
CCoeControl* coeControl = ControlOrNull( aControlId );
if ( coeControl )
{
HBufC* buf = NULL;
switch ( aControlId )
{
case EMPXMetadataEditorDlgCtrlIdSongName:
case EMPXMetadataEditorDlgCtrlIdArtist:
case EMPXMetadataEditorDlgCtrlIdAlbum:
case EMPXMetadataEditorDlgCtrlIdComment:
case EMPXMetadataEditorDlgCtrlIdComposer:
case EMPXMetadataEditorDlgCtrlIdTrackNumber:
{
CEikEdwin* control = static_cast<CEikEdwin*>( coeControl );
if ( control )
{
buf = control->GetTextInHBufL();
if ( !buf )
{
// the text contains nothing
// special handling is needed for song name
if ( aControlId == EMPXMetadataEditorDlgCtrlIdSongName && iMedia )
{
if ( iMedia->IsSupported( KMPXMediaGeneralUri ) )
{
// if URI is defined, use filename as song name
TParsePtrC fn( iMedia->ValueText( KMPXMediaGeneralUri ) );
buf = fn.Name().AllocL();
}
else
{
buf = HBufC::NewL( 0 );
}
}
else
{
buf = HBufC::NewL( 0 );
}
}
CleanupStack::PushL( buf );
}
else
{
// should not reach here
User::Leave( KErrArgument );
}
break;
}
default:
{
// should not reach here
User::Leave( KErrArgument );
break;
}
}
if ( buf )
{
const TDesC& origValue = iMedia->ValueText( aAttribute );
if ( origValue.Compare( *buf ) != 0 )
{
//check if the track number is actually changed
if (aControlId == EMPXMetadataEditorDlgCtrlIdTrackNumber &&
origValue.Compare(_L("")) == 0 &&
buf->Compare(_L("0")) == 0)
{
//nothing to do
}
else
{
ret = ETrue;
iMedia->SetTextValueL( aAttribute , *buf );
aMedia->SetTextValueL( aAttribute , *buf );
}
}
CleanupStack::PopAndDestroy( buf );
}
}
return ret;
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::PopulateFileDetailsL
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::PopulateFileDetailsL()
{
MPX_FUNC( "CMPXMetadataEditorDialog::PopulateFileDetailsL" );
ASSERT(iMedia);
TBool drmProtected(iMedia->ValueTObjectL<TBool> (KMPXMediaDrmProtected));
MPX_DEBUG2( "CMPXMetadataEditorDialog::PopulateFileDetailsL drm protected: %d", drmProtected );
if (drmProtected)
{
HBufC* detail = StringLoader::LoadLC( R_MPX_CUI_LICENCE_DET_LINK );
SetControlTextL(EMPXMetadataEditorDlgCtrlIdDRMDetail, detail->Des(),
KNullDesC);
CleanupStack::PopAndDestroy( detail );
}
else
{
DeleteLine(EMPXMetadataEditorDlgCtrlIdDRMDetail,EFalse);
}
// Get filename
const TDesC& uri = iMedia->ValueText(KMPXMediaGeneralUri);
TParsePtrC parse(uri);
SetControlTextL(EMPXMetadataEditorDlgCtrlIdFileName, parse.Name(),
KNullDesC);
// Get mime type
SetControlTextL(EMPXMetadataEditorDlgCtrlIdFileFormat, iMedia->ValueText(
KMPXMediaGeneralMimeType), KNullDesC);
// Get duration
TInt duration(iMedia->ValueTObjectL<TInt> (KMPXMediaGeneralDuration));
if (duration > 0)
{
// convert milliseconds to seconds
duration = duration / KSecondInMilliseconds;
CMPXCommonUiHelper::TMPXDuratDisplayMode durationMode =
CMPXCommonUiHelper::EMPXDuratAuto;
if (duration > KOneHourInSeconds)
{
durationMode = CMPXCommonUiHelper::EMPXDuratHMS;
}
HBufC* stringBuf = iCommonUiHelper->DisplayableDurationL(duration,
durationMode);
CleanupStack::PushL(stringBuf);
SetControlTextL(EMPXMetadataEditorDlgCtrlIdFileDuration, *stringBuf,
KNullDesC);
CleanupStack::PopAndDestroy(stringBuf);
}
else
{
SetControlTextL(EMPXMetadataEditorDlgCtrlIdFileDuration, KNullDesC,
KNullDesC);
}
// Get bitrate
TInt bitrate(iMedia->ValueTObjectL<TInt> (KMPXMediaAudioBitrate));
if (bitrate > 0)
{
// convert bitrate to kpbs
bitrate = bitrate / KMPXBitrateFactor;
HBufC* bitrateText = StringLoader::LoadLC(
R_MPX_CUI_METADATAEDITOR_BITRATE_TXT, bitrate);
SetControlTextL(EMPXMetadataEditorDlgCtrlIdFileBitrate,
bitrateText->Des(), KNullDesC);
CleanupStack::PopAndDestroy(bitrateText);
}
else
{
SetControlTextL(EMPXMetadataEditorDlgCtrlIdFileBitrate, KNullDesC,
KNullDesC);
}
// Get sampling rate
TInt samplingRateNum((TInt) iMedia->ValueTObjectL<TInt> (
KMPXMediaAudioSamplerate));
if (samplingRateNum > 0)
{
HBufC* stringBuf = HBufC::NewLC(KMPXFileDetailsMaxBufferLen);
TPtr stringBufPtr = stringBuf->Des();
stringBufPtr.AppendNum(samplingRateNum);
AknTextUtils::LanguageSpecificNumberConversion( stringBufPtr );
HBufC* samplingrate = StringLoader::LoadLC(
R_MPX_CUI_METADATAEDITOR_SAMPLINGRATE_TXT, stringBufPtr);
SetControlTextL(EMPXMetadataEditorDlgCtrlIdSamplingrate,
samplingrate->Des(), KNullDesC);
CleanupStack::PopAndDestroy(samplingrate);
CleanupStack::PopAndDestroy(stringBuf);
}
else
{
SetControlTextL(EMPXMetadataEditorDlgCtrlIdSamplingrate, KNullDesC,
KNullDesC);
}
// Get size, not stored in collection, have to use RFile
//
RFs& fs = CEikonEnv::Static()->FsSession();
RFile file;
TInt sizeNum(0);
TInt err(file.Open(fs, uri, EFileRead | EFileShareReadersOrWriters));
if (err == KErrNone)
{
file.Size(sizeNum);
file.Close();
}
if (sizeNum > 0)
{
HBufC* stringBuf = iCommonUiHelper->UnitConversionL(sizeNum);
CleanupStack::PushL(stringBuf);
TPtr stringBufPtr = stringBuf->Des();
AknTextUtils::DisplayTextLanguageSpecificNumberConversion(stringBufPtr);
SetControlTextL(EMPXMetadataEditorDlgCtrlIdSize, stringBufPtr,
KNullDesC);
CleanupStack::PopAndDestroy(stringBuf);
}
else
{
SetControlTextL(EMPXMetadataEditorDlgCtrlIdSize, KNullDesC, KNullDesC);
}
if (iCurrentLibrary == EMPXMetadataEditorDlgPodcast)
{
PopulatePodcastFileDetailsL();
}
// Get last modified time
TTime time;
User::LeaveIfError( fs.Modified( uri, time ) );
ConvertToLocalTimeL( time );
HBufC* modDateTime = HBufC::NewLC(
KMPXMaxTimeLength + KMPXDurationDisplayResvLen );
HBufC* format = StringLoader::LoadLC(
R_QTN_DATE_USUAL_WITH_ZERO );
TPtr modDatePtr = modDateTime->Des();
MPX_TRAPD( error, time.FormatL( modDatePtr, *format ) );
CleanupStack::PopAndDestroy( format );
if ( error != KErrNone)
{
SetControlTextL(EMPXMetadataEditorDlgCtrlIdLastModified,
KNullDesC, KNullDesC);
}
else
{
format = StringLoader::LoadLC(
R_QTN_TIME_USUAL_WITH_ZERO );
HBufC* modTime = HBufC::NewLC(
format->Length() + KMPXDurationDisplayResvLen );
TPtr modTimePtr = modTime->Des();
MPX_TRAPD( err, time.FormatL( modTimePtr, *format ) );
if ( err != KErrNone )
{
SetControlTextL(EMPXMetadataEditorDlgCtrlIdLastModified,
KNullDesC, KNullDesC);
}
else
{
modDatePtr.Append( KMPXSpace );
modDatePtr.Append( modTimePtr );
AknTextUtils::DisplayTextLanguageSpecificNumberConversion(modDatePtr);
SetControlTextL(EMPXMetadataEditorDlgCtrlIdLastModified,
modDatePtr,
KNullDesC);
}
CleanupStack::PopAndDestroy( modTime );
CleanupStack::PopAndDestroy( format );
}
CleanupStack::PopAndDestroy( modDateTime );
// Get filename
SetControlTextL(EMPXMetadataEditorDlgCtrlIdCopyright,
iMedia->ValueText(
KMPXMediaGeneralCopyright ), KNullDesC);
// Get URL
SetControlTextL(EMPXMetadataEditorDlgCtrlIdWebaddress,
iMedia->ValueText(
KMPXMediaMusicURL ), KNullDesC);
CAknForm::SetInitialCurrentLine();
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::PopulatePodcastFileDetailsL
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::PopulatePodcastFileDetailsL()
{
TInt lastPbPosition((TInt) iMedia->ValueTObjectL<TInt> (
KMPXMediaGeneralLastPlaybackPosition ));
if (lastPbPosition > 0)
{
// convert milliseconds to seconds
lastPbPosition = lastPbPosition / KSecondInMilliseconds;
CMPXCommonUiHelper::TMPXDuratDisplayMode lastPbPositionMode =
CMPXCommonUiHelper::EMPXDuratAuto;
if (lastPbPosition > KOneHourInSeconds)
{
lastPbPositionMode = CMPXCommonUiHelper::EMPXDuratHMS;
}
HBufC* stringBuf = iCommonUiHelper->DisplayableDurationL(
lastPbPosition, lastPbPositionMode);
CleanupStack::PushL(stringBuf);
SetControlTextL(EMPXMetadataEditorDlgCtrlIdLastPlayedPosition,
*stringBuf, KNullDesC);
CleanupStack::PopAndDestroy(stringBuf);
}
else if (lastPbPosition == 0 && iMedia->IsSupported(
KMPXMediaGeneralPlayCount) && iMedia->ValueTObjectL<TInt> (
KMPXMediaGeneralPlayCount) > 0)
{
HBufC* stringBuf = StringLoader::LoadLC(
R_MPX_CUI_METADATAEDITOR_PLAYBACK_COMPLETE);
SetControlTextL(EMPXMetadataEditorDlgCtrlIdLastPlayedPosition,
*stringBuf, KNullDesC);
CleanupStack::PopAndDestroy(stringBuf);
}
else
{
SetControlTextL(EMPXMetadataEditorDlgCtrlIdLastPlayedPosition,
KNullDesC, KNullDesC);
}
// Get published
if (iMedia->IsSupported(TMPXAttribute(KMPXMediaIdPodcast,
EMPXMediaPodcastPubDate)))
{
TInt64 timeInt(
(TInt64) iMedia->ValueTObjectL<TInt64> (TMPXAttribute(
KMPXMediaIdPodcast, EMPXMediaPodcastPubDate)));
TTime time(timeInt);
ConvertToLocalTimeL(time);
HBufC* modDateTime = HBufC::NewLC(KMPXMaxTimeLength
+ KMPXDurationDisplayResvLen);
HBufC* format = StringLoader::LoadLC(R_QTN_DATE_USUAL_WITH_ZERO);
TPtr modDatePtr = modDateTime->Des();
MPX_TRAPD( err, time.FormatL( modDatePtr, *format ) );
CleanupStack::PopAndDestroy(format);
if (err != KErrNone || time == 0)
{
SetControlTextL(EMPXMetadataEditorDlgCtrlIdLastPublished,
KNullDesC, KNullDesC);
}
else
{
format = StringLoader::LoadLC(R_QTN_TIME_USUAL_WITH_ZERO);
HBufC* modTime = HBufC::NewLC(format->Length()
+ KMPXDurationDisplayResvLen);
TPtr modTimePtr = modTime->Des();
MPX_TRAPD( err, time.FormatL( modTimePtr, *format ) );
if (err != KErrNone)
{
SetControlTextL(EMPXMetadataEditorDlgCtrlIdLastPublished,
KNullDesC, KNullDesC);
}
else
{
modDatePtr.Append(KMPXSpace);
modDatePtr.Append(modTimePtr);
SetControlTextL(EMPXMetadataEditorDlgCtrlIdLastPublished,
modTimePtr, KNullDesC);
}
CleanupStack::PopAndDestroy(modTime);
CleanupStack::PopAndDestroy(format);
}
CleanupStack::PopAndDestroy(modDateTime);
}
else
{
SetControlTextL(EMPXMetadataEditorDlgCtrlIdLastPublished,
KNullDesC, KNullDesC);
}
}
// -----------------------------------------------------------------------------
// CMPXMetadataEditorDialog::LaunchDrmInfoL
// -----------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::LaunchDrmInfoL()
{
MPX_FUNC( "CMPXMetadataEditorDialog::LaunchDrmInfoL" );
const TDesC& aFileName = iMedia->ValueText(KMPXMediaGeneralUri);
RFs fs;
User::LeaveIfError( fs.Connect() );
CleanupClosePushL( fs );
RFile64 drmFile;
User::LeaveIfError( drmFile.Open(
fs, aFileName, EFileRead | EFileShareReadersOrWriters ) );
CleanupClosePushL( drmFile );
iDrmUiHandler->ShowDetailsViewL( drmFile );
CleanupStack::PopAndDestroy( &drmFile );
CleanupStack::PopAndDestroy( &fs );
}
// ---------------------------------------------------------------------------
// From MMPXPlaybackCallback
// Handle playback property.
// ---------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::HandlePropertyL(
TMPXPlaybackProperty aProperty,
TInt aValue,
TInt aError )
{
MPX_FUNC( "CMPXMetadataEditorDialog::HandleSubPlayerNamesL" );
}
// ---------------------------------------------------------------------------
// From MMPXPlaybackCallback
// Method is called continously until aComplete=ETrue, signifying that
// it is done and there will be no more callbacks
// Only new items are passed each time
// ---------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::HandleSubPlayerNamesL(
TUid /* aPlayer */,
const MDesCArray* /* aSubPlayers */,
TBool /* aComplete */,
TInt /* aError */ )
{
MPX_FUNC( "CMPXMetadataEditorDialog::HandleSubPlayerNamesL" );
}
// ---------------------------------------------------------------------------
// From MMPXPlaybackCallback
// Handle media properties.
// Notes: The client is responsible for delete the object of aMedia.
// ---------------------------------------------------------------------------
//
void CMPXMetadataEditorDialog::HandleMediaL(
const CMPXMedia& aMedia,
TInt aError )
{
MPX_FUNC( "CMPXMetadataEditorDialog::HandleMediaL" );
TRAP_IGNORE( DoHandleMediaL( aMedia, aError ) );
}
// End of File