/// @todo minor: Rowland Cook 12/06/2007 Add method decription.
// -----------------------------------------------------------------------------
// TGlxCommandFactory::AddToContainerCommandLC
// -----------------------------------------------------------------------------
//
EXPORT_C CMPXCommand* TGlxCommandFactory::AddToContainerCommandLC(
const TDesC& aUri,
const CMPXCollectionPath& aTargetContainers)
{
CMPXCommand* command = CMPXCommand::NewL();
CleanupStack::PushL(command);
// Set command id
command->SetTObjectValueL<TInt>(KMPXCommandGeneralId, KGlxCommandIdAdd);
// Set URI
command->SetTextValueL(KMPXCommandGeneralSourceUri, aUri);
// Add path of selected items
command->SetCObjectValueL<CMPXCollectionPath>(KMPXMediaGeneralContainerId, &const_cast<CMPXCollectionPath&>(aTargetContainers));
// Add collection plugin id to command object
/// @todo minor: Add comment as to the meaning of the value zero in Comparison and aTargetContainers.Id(0)
if (aTargetContainers.Levels() > 0)
{
command->SetTObjectValueL<TUid>(KMPXCommandGeneralCollectionId, TUid::Uid(aTargetContainers.Id(0)));
}
return command;
}
/// @todo minor: Rowland Cook 12/06/2007 Add method decription.
// -----------------------------------------------------------------------------
// TGlxCommandFactory::SetDescriptionCommandLC
// -----------------------------------------------------------------------------
//
EXPORT_C CMPXCommand* TGlxCommandFactory::SetDescriptionCommandLC(const TDesC& aDescription,
const CMPXCollectionPath& aSourcePath)
{
CMPXCommand* command = BasicCommandLC(KGlxCommandIdSet, aSourcePath);
// Set description
command->SetTextValueL(KMPXMediaGeneralComment, aDescription);
return command;
}
/// @todo minor: Rowland Cook 12/06/2007 Add method decription.
// -----------------------------------------------------------------------------
// TGlxCommandFactory::RenameCommandLC
// -----------------------------------------------------------------------------
//
EXPORT_C CMPXCommand* TGlxCommandFactory::RenameCommandLC(const TDesC& aNewTitle,
const CMPXCollectionPath& aSourcePath)
{
CMPXCommand* command = BasicCommandLC(KGlxCommandIdSet, aSourcePath);
// Set title
command->SetTextValueL(KMPXMediaGeneralTitle, aNewTitle);
return command;
}
/// @todo minor: Rowland Cook 12/06/2007 Add method decription.
// -----------------------------------------------------------------------------
// TGlxCommandFactory::CopyCommandLC
// -----------------------------------------------------------------------------
//
EXPORT_C CMPXCommand* TGlxCommandFactory::CopyCommandLC(const TDesC& aTargetDrive,
const CMPXCollectionPath& aSourcePath)
{
CMPXCommand* command = BasicCommandLC(KGlxCommandIdAdd, aSourcePath);
// Set target drive
command->SetTextValueL(KMPXMediaGeneralDrive, aTargetDrive);
return command;
}
/// @todo minor: Rowland Cook 12/06/2007 Add method decription.
// -----------------------------------------------------------------------------
// TGlxCommandParser::ValueL
// -----------------------------------------------------------------------------
//
template<typename T> T TGlxCommandParser::ValueL(const TMPXAttribute & aAttribute, const CMPXCommand& aCommand)
{
if ( !aCommand.IsSupported(aAttribute) )
{
User::Leave(KErrArgument);
}
return aCommand.ValueTObjectL<T>(aAttribute);
}
/// @todo minor: Rowland Cook 12/06/2007 Add method decription.
// -----------------------------------------------------------------------------
// TGlxCommandFactory::AddContainerCommandLC
// -----------------------------------------------------------------------------
//
EXPORT_C CMPXCommand* TGlxCommandFactory::AddContainerCommandLC(const TDesC& aTitle,
TInt aCollectionUid)
{
CMPXCommand* command = CMPXCommand::NewL();
CleanupStack::PushL(command);
// Add collection plugin id to command object
command->SetTObjectValueL<TUid>(KMPXCommandGeneralCollectionId, TUid::Uid(aCollectionUid));
// Set command id
command->SetTObjectValueL<TInt>(KMPXCommandGeneralId, KGlxCommandIdAdd);
// Set title of new object
command->SetTextValueL(KMPXMediaGeneralTitle, aTitle);
return command;
}
/// @todo minor: Rowland Cook 12/06/2007 Add method decription.
// -----------------------------------------------------------------------------
// TGlxCommandParser::IdsL
// -----------------------------------------------------------------------------
//
EXPORT_C TBool TGlxCommandParser::IdsL(TUid& aCollectionUid, TUint32& aSessionId, const CMPXCommand& aCommand)
{
aCollectionUid = ValueL<TUid>(KMPXCommandGeneralCollectionId, aCommand);
if ( aCommand.IsSupported(KMPXCommandGeneralSessionId) )
{
aSessionId = aCommand.ValueTObjectL<TUint32>(KMPXCommandGeneralSessionId);
return ETrue;
}
else
{
return EFalse;
}
}
/// @todo minor: Rowland Cook 12/06/2007 Add method decription.
// -----------------------------------------------------------------------------
// TTGlxCommandParser::ArrayValueL
// -----------------------------------------------------------------------------
//
void TGlxCommandParser::ArrayValueL(const TMPXAttribute & aAttribute, RArray<TGlxMediaId>& aArray, const CMPXCommand& aCommand)
{
if (!aCommand.IsSupported(aAttribute) || aCommand.Type(aAttribute) != EMPXTypeCObject)
{
User::Leave(KErrArgument);
}
const CMPXCollectionPath* path = aCommand.ValueCObjectL<CMPXCollectionPath>(aAttribute);
RArray<TMPXItemId> list;
path->SelectionL(list);
if (list.Count() == 0) // append the current item
{
aArray.AppendL(TGlxMediaId(path->Id()));
}
else
{
for( TInt i = 0 ; i < list.Count() ; i++ )
{
aArray.AppendL(TGlxMediaId(list[i]));
}
}
}
// ---------------------------------------------------------------------------
// rename a media object
// ---------------------------------------------------------------------------
//
void CMPXCollectionHelperImp::RenameL( const TDesC& aOldUri,
const TDesC& aNewUri,
TMPXGeneralCategory aItemCat )
{
MPX_FUNC("CMPXCollectionHelperImp::RenameL");
MPX_DEBUG3("aOldUri = %S, aNewUri = %S", &aOldUri, &aNewUri);
if (aItemCat != EMPXSong && aItemCat != EMPXPlaylist && aItemCat != EMPXAbstractAlbum)
{
User::Leave(KErrArgument);
}
// find the media using the old URI
RArray<TMPXAttribute> attributes;
CleanupClosePushL( attributes );
attributes.AppendL(KMPXMediaGeneralId);
attributes.AppendL(KMPXMediaMusicAlbumArtFileName);
CMPXMedia* media = GetL(aOldUri, attributes.Array(), aItemCat);
CleanupStack::PopAndDestroy(&attributes);
CleanupStack::PushL(media);
const TDesC& fileName(media->ValueText(KMPXMediaMusicAlbumArtFileName));
// the songs have embedded albumart.
if(fileName.CompareF(aOldUri) == 0)
{
// change the Art filename to the new Uri
media->SetTextValueL(KMPXMediaMusicAlbumArtFileName, aNewUri);
// Rename the thumbnail
TRAPD(err, RenameThumbnailL(aOldUri, aNewUri));
if(KErrNone != err)
{
MPX_DEBUG2("Thumbnail renames failed. Err: %d", err);
}
}
// change file path to the new file path
media->SetTextValueL(KMPXMediaGeneralUri, aNewUri);
// ask harvester to rename the file if any of the following is true:
// 1) renaming a song
// 2) renaming a playlist scanned through file system.
//
// There are 3 types of playlists. The ones created from the device
// are virtual playlists which have file extension .vir. There are
// no physical playlist files associated with them; hence not
// registered with harvester. For virtual playlists, IsPlaylistL
// will return EFalse because there is not a playlist plugin that
// deals with .vir playlist files.
//
// The ones synced from PC through MTP have file extension .pla.
// There are 0-byte .pla files associated with them but they
// are not registered with harvester either. IsPlaylistL will also
// return EFalse because there is not a playlist plugin that deals
// with .pla.
//
// The 3rd type of playlists is .m3u on the file system. They are
// added to the collection through file scan and registered with
// harvester. IsPlaylistL will return ETrue.
if (aItemCat == EMPXSong || iHvsUtility->IsPlaylistL(aOldUri))
{
const TUid& collection =
media->ValueTObjectL<TUid>(KMPXMediaGeneralCollectionId);
iHvsUtility->RenameFileL( aOldUri, aNewUri, collection.iUid );
}
// Update collection via CMPXCommand
//
CMPXCommand* cmd = CMPXCommand::NewL();
CleanupStack::PushL( cmd );
cmd->SetTObjectValueL( KMPXCommandGeneralId, KMPXCommandIdCollectionSet );
TUid colId (media->ValueTObjectL<TUid>(KMPXMediaGeneralCollectionId) );
cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, colId.iUid );
cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue );
cmd->SetCObjectValueL( KMPXCommandColSetMedia, media );
iCollectionUtil->Collection().CommandL( *cmd );
CleanupStack::PopAndDestroy( cmd );
CleanupStack::PopAndDestroy(media);
}
// ---------------------------------------------------------------------------
// Remove a file from the collection
// ---------------------------------------------------------------------------
//
void CMPXCollectionHelperImp::RemoveL( const TDesC& aFile,
TMPXGeneralCategory aItemCat )
{
MPX_FUNC("CMPXCollectionHelperImp::RemoveL");
MPX_DEBUG3("aFile %S, category %d", &aFile, aItemCat);
if (aItemCat != EMPXSong && aItemCat != EMPXPlaylist)
{
User::Leave(KErrArgument);
}
//
// ask harvester to remove the file if any of the following is true:
// 1) removing a song
// 2) removing a playlist scanned through file system.
//
// There are 3 types of playlists. The ones created from the device
// are virtual playlists which have file extension .vir. There are
// no physical playlist files associated with them; hence not
// registered with harvester. For virtual playlists, IsPlaylistL
// will return EFalse because there is not a playlist plugin that
// deals with .vir playlist files.
//
// The ones synced from PC through MTP have file extension .pla.
// There are 0-byte .pla files associated with them but they
// are not registered with harvester either. IsPlaylistL will also
// return EFalse because there is not a playlist plugin that deals
// with .pla.
//
// The 3rd type of playlists is .m3u on the file system. They are
// added to the collection through file scan and registered with
// harvester. IsPlaylistL will return ETrue.
//
// For now virtual playlists and synced playlists are assumed to
// be in the music collection for now until there is a generic way
// resolving collections aside from using file extension or UID.
//
TInt collection(iMusicCollectionId.iUid);
if (aItemCat == EMPXSong || iHvsUtility->IsPlaylistL(aFile))
{
// Remove from the harvester
collection = iHvsUtility->RemoveFileL( aFile );
}
// Remove from the collection
// Construct a CMPXMedia object with URI, collection id, type and category
//
RArray<TInt> contID;
CleanupClosePushL( contID );
contID.AppendL( KMPXMediaIdGeneral );
CMPXMedia* media = CMPXMedia::NewL( contID.Array() );
CleanupStack::PushL( media );
media->SetTextValueL( KMPXMediaGeneralUri, aFile );
media->SetTObjectValueL<TUid>( KMPXMediaGeneralCollectionId, TUid::Uid( collection ) );
media->SetTObjectValueL( KMPXMediaGeneralType, EMPXItem );
media->SetTObjectValueL( KMPXMediaGeneralCategory, aItemCat );
// Remove the item via CMPXCommand
//
CMPXCommand* cmd = CMPXCommand::NewL();
CleanupStack::PushL( cmd );
cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId,
collection );
cmd->SetTObjectValueL( KMPXCommandGeneralId,
KMPXCommandIdCollectionRemoveMedia );
cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue );
cmd->SetCObjectValueL( KMPXCommandCollectionRemoveMedia, media );
cmd->SetTObjectValueL( KMPXCommandCollectionRemoveMediaDeleteRecord,
ETrue );
iCollectionUtil->Collection().CommandL( *cmd );
CleanupStack::PopAndDestroy( cmd );
CleanupStack::PopAndDestroy( media );
CleanupStack::PopAndDestroy( &contID );
}
/// @todo minor: Rowland Cook 12/06/2007 Add method decription.
// -----------------------------------------------------------------------------
// TGlxCommandParser::ParseL
// -----------------------------------------------------------------------------
//
EXPORT_C void TGlxCommandParser::ParseL(MGlxCommandParserCallback& aCommandHandler, const CMPXCommand& aCommand)
{
TUint32 commandId = ValueL<TUint32>(KMPXCommandGeneralId, aCommand);
RArray<TGlxMediaId> sourceIdArray;
CleanupClosePushL(sourceIdArray);
RArray<TGlxMediaId> targetIdArray;
CleanupClosePushL(targetIdArray);
switch (commandId)
{
case KGlxCommandIdAdd:
{
TBool hasTitle = aCommand.IsSupported(KMPXMediaGeneralTitle);
TBool hasSourceIds = aCommand.IsSupported(KMPXCommandGeneralSourceIds);
TBool hasUri = aCommand.IsSupported(KMPXCommandGeneralSourceUri);
TBool hasTargetIds = aCommand.IsSupported(KMPXMediaGeneralContainerId);
TBool hasDrive = aCommand.IsSupported(KMPXMediaGeneralDrive);
if (hasSourceIds)
{
ArrayValueL(KMPXCommandGeneralSourceIds, sourceIdArray, aCommand);
}
if (hasTargetIds)
{
ArrayValueL(KMPXMediaGeneralContainerId, targetIdArray, aCommand);
}
/// @todo minor: Rowland Cook 12/06/2007 Could this be restrctured to be more efficient?
// IE - Test for invalid combiations before retrieving the data.
if(hasTitle)
{
if(hasUri || hasSourceIds || hasDrive || hasTargetIds)
{
User::Leave(KErrArgument);
}
aCommandHandler.AddContainerL(DescriptorValueL(KMPXMediaGeneralTitle, aCommand));
}
else if (hasUri)
{
if (hasSourceIds || hasDrive || !hasTargetIds)
// Illegal parameter combination
{
User::Leave(KErrArgument);
}
aCommandHandler.AddToContainerL(DescriptorValueL(KMPXCommandGeneralSourceUri, aCommand), targetIdArray);
}
else if (hasSourceIds)
{
if (hasTargetIds)
{
if (hasDrive)
// Illegal parameter combination
{
User::Leave(KErrArgument);
}
aCommandHandler.AddToContainerL(sourceIdArray, targetIdArray);
}
else if (hasDrive)
{
aCommandHandler.CopyL(sourceIdArray, DescriptorValueL(KMPXMediaGeneralDrive, aCommand));
}
else
// There isn't a target
{
User::Leave(KErrArgument);
}
}
else // There isn't a source
{
User::Leave(KErrArgument);
}
break;
}
case KGlxCommandIdRemove:
{
ArrayValueL(KMPXCommandGeneralSourceIds, sourceIdArray, aCommand);
TGlxMediaId containerId (ValueL<TMPXItemId>(KMPXMediaGeneralContainerId, aCommand));
if (containerId == KGlxContainerDevice)
{
aCommandHandler.DeleteL(sourceIdArray);
}
else
{
aCommandHandler.RemoveFromContainerL(sourceIdArray, containerId);
}
break;
}
case KGlxCommandIdSet:
{
TBool hasTitle = aCommand.IsSupported(KMPXMediaGeneralTitle);
TBool hasDrive = aCommand.IsSupported(KMPXMediaGeneralDrive);
TBool hasComment = aCommand.IsSupported(KMPXMediaGeneralComment);
TBool hasLocation = aCommand.IsSupported(KGlxMediaGeneralLocation);
ArrayValueL(KMPXCommandGeneralSourceIds, sourceIdArray, aCommand);
if (hasTitle)
// Rename operation
{
if (hasDrive || hasComment || hasLocation || sourceIdArray.Count() < 1)
// Unsupported attribute combination
{
User::Leave(KErrArgument);
}
const TDesC& title = DescriptorValueL(KMPXMediaGeneralTitle, aCommand);
aCommandHandler.RenameL(sourceIdArray[0], title);
}
else if (hasDrive)
{
if(hasComment || hasLocation)
// Unsupported attribute combination
{
User::Leave(KErrArgument);
}
const TDesC& drive = DescriptorValueL(KMPXMediaGeneralDrive, aCommand);
aCommandHandler.MoveL(sourceIdArray, drive);
}
else if (hasComment)
{
if ( hasLocation )
// Unsupported attribute combination
{
User::Leave(KErrArgument);
}
const TDesC& comment = DescriptorValueL(KMPXMediaGeneralComment, aCommand);
aCommandHandler.SetDescriptionL(sourceIdArray, comment);
}
else if (hasLocation)
{
TCoordinate coordinate = aCommand.ValueTObjectL<TCoordinate>(KGlxMediaGeneralLocation);
aCommandHandler.SetCaptureLocationL(sourceIdArray, coordinate);
}
else
{
User::Leave(KErrArgument);
}
break;
}
case KGlxCommandThumbnailCleanup:
{
aCommandHandler.ThumbnailCleanupL();
break;
}
}
CleanupStack::PopAndDestroy(&targetIdArray);
CleanupStack::PopAndDestroy(&sourceIdArray);
}
// ----------------------------------------------------------------------------------------------------------
// Executes the given command on the collection
// ----------------------------------------------------------------------------------------------------------
//
void CTestCollectionPlugin::CommandL(CMPXCommand& aCmd)
{
LOG1(_L("CTestCollectionPlugin::CommandL"));
const TDesC& title = aCmd.ValueText( KMPXMediaGeneralTitle );
TMPXCommandId cmdId = aCmd.ValueTObjectL<TMPXCommandId>(KMPXCommandGeneralId);
LOG2(_L("CommandId = %d"), cmdId);
if(title == _L("CollectionPluginTest0175") )
{
}
else if(title == _L("CollectionPluginTest0176") )
{
iObs->HandleCommandComplete(NULL, KErrNone);
}
else if(title == _L("CollectionPluginTest0177") )
{
iObs->HandleCommandComplete(NULL, KErrGeneral);
}
else if(title == _L("CollectionPluginTest0183") )
{
}
else if(title == _L("CollectionPluginTest0184") )
{
CMPXCommand* newCmd = CMPXCommand::NewL();
CleanupStack::PushL( newCmd );
*newCmd = aCmd;
iObs->HandleCommandComplete(newCmd, KErrNone);
CleanupStack::PopAndDestroy( newCmd );
}
else
{
TBool syncOp(EFalse);
if( aCmd.IsSupported(KMPXCommandGeneralDoSync) )
{
syncOp = *aCmd.Value<TBool>(KMPXCommandGeneralDoSync);
}
switch( cmdId )
{
case KMPXCommandIdCollectionRetrieveUriForDeletion:
{ // TODO
LOG1(_L("CTestCollectionPlugin::CommandL - KMPXCommandIdCollectionRetrieveUriForDeletion"));
//DoRetrieveUriForDeletionL(aCmd);
break;
}
case KMPXCommandIdCollectionRemove:
{
LOG1(_L("CTestCollectionPlugin::CommandL - KMPXCommandIdCollectionRemove"));
//DoRemovePathL(aCmd);
break;
}
case KMPXCommandIdCollectionRemoveMedia:
{
LOG1(_L("CTestCollectionPlugin::CommandL - KMPXCommandIdCollectionRemoveMedia"));
//DoRemoveMediaL(aCmd);
break;
}
case KMPXCommandIdCollectionCleanupDeletedMedias:
{
LOG1(_L("CTestCollectionPlugin::CommandL - KMPXCommandIdCollectionCleanupDeletedMedias"));
//DoCleanupDeletedMediasL(aCmd);
break;
}
case KMPXCommandIdCollectionAdd:
{
LOG1(_L("CTestCollectionPlugin::CommandL - KMPXCommandIdCollectioAdd"));
CMPXMedia& media = *aCmd.Value<CMPXMedia>(KMPXCommandColAddMedia);
AddL(media);
break;
}
case KMPXCommandIdCollectionSet:
{
LOG1(_L("CTestCollectionPlugin::CommandL - KMPXCommandIdCollectionSet"));
CMPXMedia& media = *aCmd.Value<CMPXMedia>(KMPXCommandColSetMedia);
SetL( media );
break;
}
case KMPXCommandIdCollectionCompleteDelete:
{
LOG1(_L("CTestCollectionPlugin::CommandL - KMPXCommandIdCollectionCompleteDelete"));
//DoHandleDeleteCompleteL( aCmd );
break;
}
default:
{
User::Panic(_L("CTestCollectionPlugin::CommandL panic"), 1); // magic number
}
}
if (!syncOp)
{
iObs->HandleCommandComplete( NULL, KErrNone );
}
}
}
