/*

* Copyright (c) 2009 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:   VideoCollectionListener class definition*

*/

#ifndef __VIDEOCOLLECTIONLISTENER_H

#define __VIDEOCOLLECTIONLISTENER_H

// INCLUDES

#include <QObject>

#include <mpxcollectionobserver.h>

// FORWARD DECLARATIONS

class VideoCollectionClient;

class VideoCollectionUtils;

class VideoDataSignalReceiver;

// CLASS DECLARATION

class VideoCollectionListener : public QObject, public MMPXCollectionObserver

{

    /**

     * define to be able to use signals and slots

     */

    Q_OBJECT

    /**

     * disable copy-constructor and assignment operator

     */

    Q_DISABLE_COPY(VideoCollectionListener) 

public: 

    /**

     * Constructor

     */

    VideoCollectionListener(VideoCollectionClient &collectionClient,

                            VideoDataSignalReceiver &mSignalReceiver);

    /**

     * Destructor.

     */

    virtual ~VideoCollectionListener();

signals:

    /**

     * Emitted when new video list is available.

     * 

     * If client needs to maintains media-array, it should create

     * a copy from provided array pointer

     * 

     * @param pointer to new media array, ownership is NOT transferred

     */

    void newVideoList(CMPXMediaArray*);

    /**

     * Emitted from HandleOpenL when mNewArrayRequest is false.

     * In this case we moght have not got all videos from previous

     * HandleOpenL so we need to provide this list to client for it to

     * check wether there are some new videos to be appended

     * 

     * @param pointer to appendable media array, ownership is NOT transferred

     */

    void videoListAppended(CMPXMediaArray*);       

    /**

     * Emitted when a single video item has fetched.

     * 

     * @param pointer to Video item. Ownership is NOT transferred

     */

    void newVideoAvailable(CMPXMedia*);

    /**

     * Emitted when received an avent about externally removed video.

     * 

     * @param video id

     */

    void videoDeleted(TMPXItemId);

    /**

     * Emitted when multiple video deletion command is completed.

     * 

     * @param int contains count of overall deleted items

     * @param media-array containing possible failed medias. Ownership is NOT transferred

     */

    void videoDeleteCompleted(int, QList<TMPXItemId>*);

    /**

     * Emitted when all details for a video have been fetched.

     * 

     * @param id of video whose details have bee fetched.

     */

    void videoDetailsCompleted(TMPXItemId);

    /**

     * Emitted when album items are recieved.

     * 

     * @param albumId, Album which items are received.

     * @param albumItems, Items belonging to the current album.

     */

    void albumListAvailable(TMPXItemId albumId, CMPXMediaArray *albumItems);

private: // From MMPXCollectionObserver

    /**

     * Handle extended media properties

     *

     * not implemented here

     * 

     * @param aMedia media 

     * @param aError error code    

     */

    void HandleCollectionMediaL( const CMPXMedia& aMedia, TInt aError );

    /**

     * Handles the collection entries being opened. Typically called

     * when client has Open()'d a folder.

     * Uses mNewArrayRequest flag to indicate wether newVideoList or

     * videoArrayAppended is emitted. If flag value is true, newVideolist 

     * is emitted and flag value is setted false. This is because only one 

     * newVideoList signal alloved per content request. 

     *

     * @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 );

    /**

     * Handles the item being opened. Typically called

     * when client has Open()'d an item. Client typically responds by

     * 'playing' the item via the playlist.

     * 

     * Not implemented here.

     *

     * @param aPlaylist collection playlist

     * @param aError error code   

     */                         

    void HandleOpenL( const CMPXCollectionPlaylist& aPlaylist, TInt aError );

    /**

     * 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 );

    /** 

     * 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 ); 

private: 

    /**

     * Default constructor should not be used

     */

    VideoCollectionListener();

    /**

     * called by the HandleCollectionMessage(), in case message received

     * contains array -based data.

     * 

     * @param aMessage

     */

    void handleMyVideosMessageArray(CMPXMessage *aMessage);

    /**

     * redirects the actual messagehandling based on given myVideosMsgId.

     * Messages to handle contains KVcxCommandIdMyVideos as their 

     * general message id 

     * 

     * @param myVideosMsgId message id parsed by the caller

     * @param aMessage

     */

    void handleMyVideosMPXMessage(int &myVideosMsgId, CMPXMessage *aMessage);

    /**

     * messages that do fall into KVcxCommandIdMyVideos, are passed here 

     * to be treated as "common" mpx messages.

     * 

     * @param myVideosMsgId message id parsed by the caller

     * @param aMessage

     */

    void handleMPXMessage(TMPXMessageId &mpxMsgId, CMPXMessage *aMessage);

    /**

     * Handles general MPX message (TMPXMessageId == KMPXMessageGeneral)

     * In here we handle only the collection opening case: when collection

     * informs it has opened and browsed to all videos category, we need to 

     * open collection to it's current state in order to get video list. 

     * 

     * @param aMessage collection message.

     */

    void handleGeneralMPXMessage(CMPXMessage* aMessage); 

    /**

     * Handles item changed message.

     * 

     * @param aMessage collection message.

     */

    void handleMyVideosItemsChanged( CMPXMessage* aMessage);        

    /**

     * Handles delete related message.

     * 

     * @param aMessage collection message.

     */

    void handleMyVideosDeleteMessage(CMPXMessage* aMessage);         

    /**

     * Handles response message when MPX Media object requested.

     *

     * @param aMessage collection message.

     */

    void handleGetMediasByMpxIdResp(CMPXMessage* aMessage);

    /**

    * Handles response message when video details requested.

    * 

    * @param aMessage collection message.

    */

    void handleGetVideoDetailsResp(CMPXMessage* aMessage);

private:

    /**

     * Reference to collection client

     */

    VideoCollectionClient &mCollectionClient;

    /**

     * reference to collection message signal receiver.

     * Used as observer for performance.

     */

    VideoDataSignalReceiver &mSignalReceiver;

    /**

     * Reference to utility objetc used to parse CMPXMessages and

     * CMPXMedias

     */

    VideoCollectionUtils &mVideoUtils;

 };

#endif // __VIDEOCOLLECTIONLISTENER_H