/*

* 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.