videocollection/mpxmyvideoscollection/tsrc/mpxmvcolltest/inc/VCXMyVideosCollectionPluginTester.h
/*
* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*/
#ifndef VCXMYVIDEOSCOLLECTIONPLUGINTESTER_H
#define VCXMYVIDEOSCOLLECTIONPLUGINTESTER_H
// INCLUDES
#include <StifLogger.h>
#include <TestScripterInternal.h>
#include <StifTestModule.h>
#include <mpxcollectionobserver.h>
#include "MVCXMyVideosCollectionPluginTesterObserver.h"
#include <mpxmediabase.h>
#include <f32file.h>
#include "MVcxTestTimerObserver.h"
#include "VCXMyVideosTestTransactions.h"
// CONSTANTS
const TUint KOpenCollectionActionId = 10000001;
const TUint KOpenCollectionLevelActionId = 10000002;
const TUint KRefreshCollectionActionId = 10000003;
const TUint KGetMediaFullDetailsActionId = 10000004;
const TUint KSideloadVideoActionId = 10000005;
const TUint KRemoveMediaActionId = 10000006;
// MACROS
// FORWARD DECLARATIONS
class MMPXCollectionUtility;
class CVCXMyVideosTestUtils;
class CVcxTestActiveWait;
// DATA TYPES
// CLASS DECLARATION
/**
* CVCXMyVideosCollectionPluginTester test class
*
* @lib ?library
* @since ?Series60_version
*/
class CVCXMyVideosCollectionPluginTester : public CBase,
public MMPXCollectionObserver
{
public: // Constructors and destructor
/**
* Two-phased constructor.
*/
static CVCXMyVideosCollectionPluginTester* NewL( MVCXMyVideosCollectionPluginTesterObserver* aObserver,
CVCXMyVideosTestUtils* aTestUtil );
/**
* Destructor.
*/
virtual ~CVCXMyVideosCollectionPluginTester();
public: // New functions
/**
* Opens MPX collection.
* Observer gets message when action is finished.
*/
void OpenCollectionL( TUint32 aCollectionUid );
/**
* Opens MPX collection level.
* Observer gets message when action is finished.
*/
void OpenLevelL( const TDesC& aLevelName );
/**
* Opens MPX collection level at specified index of current mpx item list.
* Observer gets message when action is finished.
*/
void OpenLevelL( TInt aIndex );
/**
* Gets medias by their MPX IDs. A collection must be opened before calling this.
* The returned medias are handled as when opening collection.
* @param aStartIndex, start index in iMediaArray, first media to get.
* @param aEndIndex, end index in iMediaArray, last media to get.
*/
void GetMediasByMpxIdL( TInt aStartIndex, TInt aEndIndex, TBool aSync );
/**
* Opens MPX collection level.
* Observer gets message when action is finished.
*/
void RefreshContentsL();
/**
* Closes MPX collection level or collection.
* Observer gets message when action is finished.
*/
void CloseLevelL();
/**
* Gets item from MPX and prints details for it. Copy of the media is
* stored to member variable and can be fetched with GetLastFullMedia.
* Observer gets message when action is finished.
*/
void GetMediaFullDetailsL( TInt aDrive, TInt aIndex );
/**
* Gets item from MPX and prints details for it. Copy of the media is
* stored to member variable and can be fetched with GetLastFullMedia.
* Observer gets message when action is finished.
*/
void GetMediaFullDetailsByMpxIdL( TInt aDrive, TInt aIndex, TBool aSync );
/**
* Gets the full details for all of the medias and prints them to debug output.
*/
void GetAllMediaFullDetailsL();
/**
* Prints details for items in the current MPX level. This is done when collection
* or collection level is opened.
*/
void ProcessCurrentEntriesL();
/**
* Prints MPX media object properties.
*/
void PrintMediasL( CMPXMediaArray* aMediaArray, TBool aCheckChanges, const TDesC& aTitle );
/**
* Prints MPX media object properties to debug output.
*/
void PrintMPXMediaL( const CMPXMedia& aMedia, TBool aPrintAllDetails );
/**
* Updates local data that keeps track of albums.
*/
void UpdateAlbumsListL();
/**
* Returns mpx id of album if it's found from local data.
*/
TMPXItemId GetAlbumIdL( const TDesC& aAlbumName );
/**
* Returns count of items of the open MPX level.
*/
TInt GetMediaCount();
/**
* Adds media to the collection.
* Observer gets message when action is finished.
*/
void AddMediaL( CMPXMedia* aMedia, TBool aSync );
/**
* Updates media in the collection.
* Observer gets message when action is finished.
*/
void SetMediaL( CMPXMedia* aMedia, TBool aSync );
/**
* Removes media item with command KMPXCommandIdCollectionRemoveMedia to MV MPX plugin.
*/
void RemoveMediaL( TInt aDrive, TInt aIndex, TBool aSync );
/**
* Removes media item with command KMPXCommandIdCollectionRemoveMedia to MV MPX plugin.
*/
void RemoveMediaByMpxIdL( TInt aMpxId, TBool aSync );
/**
* Deletes files of the current media entries.
*/
void DeleteAllMediaFilesL();
/**
* Deletes a file of a media in current entries.
*/
void DeleteFileOfMediaL( TInt aDrive, TInt aIndex );
/**
* Gets MPX media from current entries. Contains only brief details of the item.
*/
CMPXMedia* GetMediaL( TInt aDrive, TInt aIndex );
/**
* Gets index of media with specified name.
*
* @return index
*/
TInt GetIndexOfMediaWithNameL( const TDesC& aName );
/**
* Moves multiple medias to specified drive.
*
* @param aSourceDrive, -1 is all drives
* @param aStartIndex
* @param aEndIndex
* @param aDestDrive
* @param aSync
*/
void MoveMediasL( TInt aSourceDrive, TInt aStartIndex, TInt aEndIndex, TInt aDestDrive, TBool aSync );
/**
* Cancels move or copy request.
*/
void CancelMoveOrCopyL( TBool aSync );
/**
* Copies multiple medias to specified drive.
*
* @param aSourceDrive, -1 is all drives
* @param aStartIndex
* @param aEndIndex
* @param aDestDrive
* @param aSync
*/
void CopyMediasL( TInt aSourceDrive, TInt aStartIndex, TInt aEndIndex, TInt aDestDrive, TBool aSync );
/**
* Deletes multiple medias on specified drive.
*
* @param aSourceDrive, -1 is all drives
* @param aStartIndex
* @param aEndIndex
* @param aSync
*/
void DeleteMediasL( TInt aSourceDrive, TInt aStartIndex, TInt aEndIndex, TBool aSync );
void DeleteMediasByMpxIdsL( CMPXMediaArray* aMedias, TBool aSync );
void DeleteMediaByMpxIdL( TMPXItemId& aMpxId, TBool aSync );
/**
* Cancels move request.
*/
void CancelDeleteL( TBool aSync );
/**
* Creates an album.
*/
void CreateAlbumL( const TDesC& aAlbumName, TBool aSync, TBool aInvalidRequest = EFalse );
/**
* Deletes albums.
*/
void DeleteAlbumsL( RArray<TPtrC>& aAlbumNames );
/**
* Deletes all albums.
*/
void DeleteAllAlbumsL();
/**
* Adds medias to an album.
*
* @param aDestAlbumName
* @param aStartIndex
* @param aEndIndex
*/
void AddMediasToAlbumL( const TDesC& aAlbumName, TInt aSourceDrive, TInt aStartIndex, TInt aEndIndex );
/**
* Removes medias from an album.
*
* @param aDestAlbumName
* @param aStartIndex
* @param aEndIndex
*/
void RemoveMediasFromAlbumL( const TDesC& aAlbumName, TInt aSourceDrive, TInt aStartIndex, TInt aEndIndex );
/**
* Renames an album.
*
* @param aAlbumName
* @param aNewAlbumName
*/
void RenameAlbumL( const TDesC& aAlbumName, const TDesC& aNewAlbumName );
/**
* Use to toggle automatic refresh of contents when open collection changes.
*/
void SetAutomaticRefresh( TBool aValue );
/**
* Returns true if refresh is ongoing.
*/
TBool IsRefreshing();
/**
* Use to disable some of the logging.
*/
void SetQuietMode( TBool aValue );
/**
* Returns the index of current collection level.
*/
TInt GetCurrentLevel();
/**
* Returns the currently opened level index (category).
*/
TInt GetCurrentOpenLevelIndex();
/**
* Returns the media from last call to GetMediaDetailsL.
*/
CMPXMedia* GetLastFullMedia();
/**
* Gets index of media in collection side array.
*/
TInt GetMediaIndexInCollectionL( TInt aDrive, TInt aIndex );
/**
* Returns the video count on specified drive.
*/
TInt GetVideoCountForDrive( TInt aDrive );
/**
* Returns all medias from collection side.
*/
const CMPXMediaArray* GetAllCollectionMedia();
/**
* Ensures that files are not in use.
*/
void EnsureMediaFilesAreNotInUseL();
/**
* Creates media array with following rules:
* If startIndex is > 0 and < endIndex then these files will be selected from specified drive.
* If startIndex is -1 then invalid IDs will be used and end index is count.
* If startIndex is -2 then duplicate MPX IDs are requested starting from 0.
* If startIndex is -3 then only every second MPX item is used in request and starting from 0.
* If startIndex > endIndex then empty array is returned.
*
* @param aDriveFilter, -1 is all files. This is ignored for all other rules but the first.
* When drive is specified selection starts from index 0.
* @param aStartIndex index at current entries.
* @param aEndIndex, index at current entries.
*/
CMPXMediaArray* SelectMediasL( TInt aDriveFilter, TInt aStartIndex, TInt aEndIndex );
/**
* With this method the SelectMediasL method can be set to use copied media array
* instead of current medias. After that move, copy, delete etc. operations for
* multiple medias will use the copied media array and not current medias.
*/
void SetUseCopiedMediasL( TBool aUseCopiedMedias );
private:
/**
* Creates a MPX command.
*
* @param aCommandGeneralId
* @param aMyVideosCommandId ( this is used only if aCommandGeneralId is My Videos collection specific.
* @param aAsync
*/
CMPXCommand* CreateMpxCommandLC( TInt aCommandGeneralId, TInt aMyVideosCommandId, TBool aAsync );
/**
* Ensures that result medias array has all the medias of requested array.
*/
void CheckRequestMediaArrayL( CMPXMediaArray& aRequestResultMedias, RArray<TInt32>& aRequestedMediaIds );
/**
* Creates copies of medias in iCollectionEntries to iMediaArray and old media array is moved to
* iOldMediaArray.
*/
void UpdateOwnedMediaArrayL();
/**
* Compares iMediaArray to iOldMediaArray and returns copies if any of the medias are different.
*/
CMPXMediaArray* GetChangedMedias( const CMPXMediaArray* aNewMedias );
/**
* Returns media from the aMedias array for specified mpx id.
*/
CMPXMedia* GetMediaByMpxId( CMPXMediaArray* aMedias, TMPXItemId& aMpxId );
/**
* Sets status of refresh.
*/
void SetRefreshStatus( TBool aRefreshingCollection );
/**
* Creates copy of iMediaArray to iMediaArrayCopy.
*/
void CreateCopyOfCurrentMediasL();
public: // Functions from base classes
/**
* From MMPXCollectionObserver->MMPXCollectionMediaObserver
* Handle extended media properties
*
* @param aMedia media
* @param aError error code
*/
virtual void HandleCollectionMediaL( const CMPXMedia& aMedia, TInt aError );
/**
* From MMPXCollectionUtilityObserver.
* Handle collection message
* NOTE: only one of HandleCollectionMessage callback can be implemented
*
* @param aMessage collection message, ownership not transferred.
* Please check aMsg is not NULL before using it. If aErr is not
* KErrNone, plugin might still call back with more info in the aMsg.
* @param aErr system error code.
*/
void HandleCollectionMessage( CMPXMessage* aMsg, TInt /*aErr*/ );
void HandleSingleCollectionMessageL( CMPXMessage* aMessage );
/**
* From MMPXCollectionUtilityObserver.
* Handles the collection entries being opened. Typically called
* when client has Open()'d a folder
*
* @param aEntries collection entries opened
* @param aIndex focused entry
* @param aComplete ETrue no more entries. EFalse more entries
* expected
* @param aError error code
*/
void HandleOpenL( const CMPXMedia& aEntries,
TInt aIndex,TBool aComplete,TInt aError );
/**
* From MMPXCollectionUtilityObserver.
* Handles the item being opened. Typically called
* when client has Open()'d an item. Client typically responds by
* 'playing' the item via the playlist
*
* @param aPlaylist collection playlist
* @param aError error code
*/
void HandleOpenL( const CMPXCollectionPlaylist& aPlaylist,TInt aError );
/**
* From MMPXCollectionUtilityObserver.
* Handle completion of a asynchronous command
* @param aCommandResult result of the command, NULL if error
* @param aError error code
*/
void HandleCommandComplete( CMPXCommand* aCommandResult,
TInt aError);
private:
/**
* C++ default constructor.
*/
CVCXMyVideosCollectionPluginTester( MVCXMyVideosCollectionPluginTesterObserver* aObserver,
CVCXMyVideosTestUtils* aTestUtils );
/**
* By default Symbian 2nd phase constructor is private.
*/
void ConstructL();
private: // Data
// MVCXMyVideosCollectionPluginTesterObserver
MVCXMyVideosCollectionPluginTesterObserver* iObserver;
// UID of currently open collection.
TUid iCollectionUid;
// The index of last level which was opened.
TInt iCurrentOpenedLevelIndex;
HBufC* iCurrentLevelName;
// MMPXCollectionUtility.
MMPXCollectionUtility* iCollectionUtility;
// Entries from collection.
CMPXMedia* iCollectionEntries;
// Media array of videos on collection side.
CMPXMediaArray* iCollectionMediaArray;
// Media array of videos tests uses.
CMPXMediaArray* iMediaArray;
// Media array of videos tests uses, copy.
CMPXMediaArray* iMediaArrayCopy;
// Media array of previous videos.
CMPXMediaArray* iOldMediaArray;
// Count of current medias in iMediaArray.
TUint32 iMediaCount;
// CVCXMyVideosTestUtils.
CVCXMyVideosTestUtils* iTestUtils;
// RFs.
RFs iFs;
// Refresh is already ongoing.
TBool iRefreshingCollection;
// Active wait
CVcxTestActiveWait* iActiveWait;
// Refresh contents of open collection when they change
TBool iAutomaticContentRefresh;
// Tester is waiting for item change.
TBool iWaitingForItemChange;
// Ids of medias for commands that use multiple medias.
RArray<TInt32> iRequestedMediaIds;
// Full details of media got from GetMediaDetailsL
CMPXMedia* iFullMedia;
TBool iGettingFullDetailsForAllMedia;
// Item ids which have been deleted in change event.
RArray<TUint32> iDeletedItemIds;
// Item ids which have been inserted in change event.
RArray<TUint32> iInsertedItemIds;
CVCXMyVideosTestTransactions* iTransactions;
TBool iQuietMode;
// Canceling Move, Copy or Delete cause commmand completion with error KErrCancel
TBool iCancelRequested;
TInt iActionCount;
TInt iVideosOnRomCount;
// Arrays to hold info of albums.
RPointerArray<HBufC> iAlbumNames;
RArray<TMPXItemId> iAlbumIds;
TBool iUseCopiedMedias;
};
#endif // VCXMYVIDEOSCOLLECTIONPLUGINTESTER_H
// End of File