/*

* 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:   VideoCollectionClient class implementation

* 

*/

// INCLUDE FILES

#include <QObject>

#include <centralrepository.h>

#include <mpxcollectionutility.h>

#include <mpxcollectionpath.h>

#include <mpxmediageneraldefs.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxmessage2.h>

#include <mpxcollectionmessagedefs.h>

#include <mpxcollectionmessage.h>

#include <mpxmessagecontainerdefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include <vcxmyvideosuids.h>

#include "videodatasignalreceiver.h"

#include "videocollectionclient.h"

#include "videocollectionlistener.h"

// -----------------------------------------------------------------------------

// VideoCollectionClient()

// -----------------------------------------------------------------------------

//

VideoCollectionClient::VideoCollectionClient() :

mCollectionUtility(0),

mCollectionOpenStatus(ECollectionNotOpen),  

mCollectionListener(0),

mOpenCategoryAlbum(TMPXItemId::InvalidId()),

mCollectionPathLevel(VideoCollectionCommon::ELevelInvalid)

{

}

// -----------------------------------------------------------------------------

// initialize()

// -----------------------------------------------------------------------------

//

int VideoCollectionClient::initialize(VideoDataSignalReceiver *signalReceiver)

{

    if(!signalReceiver)

    {

        return -1;

    }

    if(mCollectionUtility && mCollectionListener)

    {

        // already initialized

        return 0;

    }

    if(!mCollectionListener)

    {

        mCollectionListener = new VideoCollectionListener(*this, *signalReceiver);

        if(!mCollectionListener)

        {

            return -1;

        }

    }

    if(!mCollectionUtility)

    {

        TRAPD( error, mCollectionUtility = MMPXCollectionUtility::NewL( mCollectionListener, KMcModeDefault ) );

        if(error)

        {

            delete mCollectionListener;

            mCollectionListener = 0;

            return error;

        }

    }

    return 0;

}

// -----------------------------------------------------------------------------

// ~VideoCollectionClient()

// -----------------------------------------------------------------------------

//

VideoCollectionClient::~VideoCollectionClient()

{

    if (mCollectionUtility)

    {

        // closing deallocates collection utility pointer

        mCollectionUtility->Close();

    }

    delete mCollectionListener;

}

// ---------------------------------------------------------------------------

// categoryIds

// ---------------------------------------------------------------------------

//

void VideoCollectionClient::getCategoryId(TMPXItemId &id)

{

    id = mOpenCategoryAlbum;

}

// ---------------------------------------------------------------------------

// getCollectionLevel

// ---------------------------------------------------------------------------

//

int VideoCollectionClient::getCollectionLevel()

{

    return mCollectionPathLevel;

}

// ---------------------------------------------------------------------------

// getOpenStatus

// ---------------------------------------------------------------------------

//

int VideoCollectionClient::getOpenStatus()

{

	return mCollectionOpenStatus;

}

// ---------------------------------------------------------------------------

// setOpenStatus

// ---------------------------------------------------------------------------

//

void VideoCollectionClient::setOpenStatus(int status)

{

    mCollectionOpenStatus = status;

    if(mCollectionOpenStatus == ECollectionOpened)

    {

        startOpenCurrentState();

    }

}

// -----------------------------------------------------------------------------

// startOpenCollection

// -----------------------------------------------------------------------------

//

int VideoCollectionClient::startOpenCollection(int level)

{

    if(!mCollectionUtility)

    {

        return -1;

    }

	if((mCollectionOpenStatus == ECollectionOpening) && (getCollectionLevel() == level))

    {

        // allready opening/opened

        return 0;

    }

    mCollectionOpenStatus = ECollectionNotOpen;

    TRAPD(error, startOpenCollectionL(level));

    return error;

}

// -----------------------------------------------------------------------------

// startOpenCurrentState

// -----------------------------------------------------------------------------

//

int VideoCollectionClient::startOpenCurrentState()

{

    int error = -1;

    if(mCollectionUtility && mCollectionOpenStatus == ECollectionOpened)

    {

        TRAP(error, mCollectionUtility->Collection().OpenL());

    }

    return error;

}

// -----------------------------------------------------------------------------

// deleteFile

// -----------------------------------------------------------------------------

int VideoCollectionClient::deleteVideos(QList<TMPXItemId> *mediaIds)

{  

    if(!mCollectionUtility || !mediaIds)

    {

        return -1;

    }    

    TRAPD(error, deleteVideosL(*mediaIds));

    return error;    

}

// -----------------------------------------------------------------------------

// openItem

// -----------------------------------------------------------------------------

//

int VideoCollectionClient::openItem(TMPXItemId &mediaId)

{

    if(!mCollectionUtility)

    {

        return -1;

    } 

    TInt error;

    if (mediaId.iId2 == KVcxMvcMediaTypeVideo)

    {

    	TRAP(error, openVideoL(mediaId));

    }

    else

    {

    	TRAP(error, openCategoryL(mediaId));

    }

    return error;

}

// -----------------------------------------------------------------------------

// back

// -----------------------------------------------------------------------------

//

int VideoCollectionClient::back()

{

    if(!mCollectionUtility)

    {

        return -1;

    } 

    TRAPD(error, backL());

    return error;

}

// -----------------------------------------------------------------------------

// fetchMpxMediaByMpxId

// -----------------------------------------------------------------------------

//

int VideoCollectionClient::fetchMpxMediaByMpxId(TMPXItemId &mpxId)

{

    if(!mCollectionUtility)

    {

        return -1;

    }

    TRAPD(error, fetchMpxMediaByMpxIdL(mpxId));

    return error;

}

// -----------------------------------------------------------------------------

// getVideoDetails

// -----------------------------------------------------------------------------

//

int VideoCollectionClient::getVideoDetails(TMPXItemId &mediaId)

{

    if(!mCollectionUtility)

    {

        return -1;

    }

    TRAPD(error, getVideoDetailsL(mediaId));

    return error;

}

// -----------------------------------------------------------------------------

// addNewAlbum

// -----------------------------------------------------------------------------

//

TMPXItemId VideoCollectionClient::addNewAlbum(const QString &title)

{

    TMPXItemId id = TMPXItemId::InvalidId();

    if (mCollectionUtility && title.length())

    {

        TRAPD(err, id = createAlbumL(title));

        if(err)

        {

            id = TMPXItemId::InvalidId();

        }

    }

    return id;

}

// -----------------------------------------------------------------------------

// removeAlbums

// -----------------------------------------------------------------------------

//

int VideoCollectionClient::removeAlbums(const QList<TMPXItemId> &mediaIds)

{

    int err(-1);

    if (mCollectionUtility && mediaIds.count())

    {

        TRAP(err, removeAlbumsL(mediaIds));

    }

    return err;

}

// -----------------------------------------------------------------------------

// addItemsInAlbum

// -----------------------------------------------------------------------------

//

int VideoCollectionClient::addItemsInAlbum(TMPXItemId &albumId,

    const QList<TMPXItemId> &mediaIds)

{

    int err(-1);

    if (mCollectionUtility && albumId != TMPXItemId::InvalidId() &&

        albumId.iId2 == KVcxMvcMediaTypeAlbum && mediaIds.count())

    {

        TRAP(err, addItemsInAlbumL(albumId, mediaIds));

    }

    return err;

}

// -----------------------------------------------------------------------------

// removeItemsFromAlbum

// -----------------------------------------------------------------------------

//

int VideoCollectionClient::removeItemsFromAlbum(TMPXItemId &albumId, 

            const QList<TMPXItemId> &mediaIds)

{

    int err(-1);

    if (mCollectionUtility && albumId != TMPXItemId::InvalidId() &&

        albumId.iId2 == KVcxMvcMediaTypeAlbum && mediaIds.count())

    {

        TRAP(err, removeItemsFromAlbumL(albumId, mediaIds));

    }

    return err;

}

// -----------------------------------------------------------------------------

// startOpenCollectionL

// -----------------------------------------------------------------------------

//

void VideoCollectionClient::startOpenCollectionL(int level)

{

    if(!mCollectionUtility)

    {

        User::Leave(KErrGeneral);

    }

    CMPXCollectionPath* collectionPath = CMPXCollectionPath::NewL();

    CleanupStack::PushL( collectionPath );

    collectionPath->AppendL( KVcxUidMyVideosMpxCollection );

    if (level == VideoCollectionCommon::ELevelVideos)

    {

    	collectionPath->AppendL( KVcxMvcCategoryIdAll );

		mOpenCategoryAlbum.iId1 = KVcxMvcCategoryIdAll;

    	mOpenCategoryAlbum.iId2 = 1;

    	mCollectionPathLevel = VideoCollectionCommon::ELevelVideos;

    }

    else

    {

        mOpenCategoryAlbum = TMPXItemId::InvalidId();

    	mCollectionPathLevel = VideoCollectionCommon::ELevelCategory;

    }

    mCollectionUtility->Collection().OpenL( *collectionPath );

    CleanupStack::PopAndDestroy( collectionPath );  

    mCollectionOpenStatus = ECollectionOpening;

}

// -----------------------------------------------------------------------------

// deleteVideosL

// -----------------------------------------------------------------------------

//

void VideoCollectionClient::deleteVideosL(QList<TMPXItemId> &mediaIds)

{

    if(!mCollectionUtility || mediaIds.count() == 0)

    {

        User::Leave(KErrGeneral);

    }

    CMPXMediaArray* mediasToDelete = CMPXMediaArray::NewL();

    CleanupStack::PushL( mediasToDelete );

    CMPXMedia* media = NULL;

    TMPXItemId currentId;

    foreach(currentId, mediaIds)

    {

        media = CMPXMedia::NewL();

        CleanupStack::PushL( media );

        media->SetTObjectValueL( KMPXMediaGeneralId, currentId );

        mediasToDelete->AppendL( *media );

        CleanupStack::PopAndDestroy( media );

    }

    CMPXCommand* cmd = CMPXMedia::NewL();

    CleanupStack::PushL( cmd );

    cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos );

    cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosDelete );    

    cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, EFalse );

    cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, 

                           TUid::Uid( KVcxUidMyVideosMpxCollection ) );

    cmd->SetCObjectValueL( KMPXMediaArrayContents, mediasToDelete );

    mCollectionUtility->Collection().CommandL( *cmd );

    CleanupStack::PopAndDestroy( cmd );  

    CleanupStack::PopAndDestroy( mediasToDelete ); 

}

// -----------------------------------------------------------------------------

// openVideoL

// -----------------------------------------------------------------------------

//

void VideoCollectionClient::openVideoL(TMPXItemId &videoId)

{

    if(!mCollectionUtility)

    {

        User::Leave(KErrGeneral);

    } 

    CMPXCollectionPath* path = CMPXCollectionPath::NewL();

    CleanupStack::PushL( path );

    path->AppendL( KVcxUidMyVideosMpxCollection );

    path->AppendL( KVcxMvcCategoryIdAll );

    path->AppendL( videoId );

    path->SelectL( videoId );

    mCollectionUtility->Collection().OpenL( *path );

    CleanupStack::PopAndDestroy( path );  

}

// -----------------------------------------------------------------------------

// openCategoryL

// -----------------------------------------------------------------------------

//

void VideoCollectionClient::openCategoryL(TMPXItemId &id)

{    

    if(!mCollectionUtility)

    {

        User::Leave(KErrGeneral);

    } 

    CMPXCollectionPath* collectionPath = CMPXCollectionPath::NewL();

    CleanupStack::PushL( collectionPath );

    collectionPath->AppendL( KVcxUidMyVideosMpxCollection );

    collectionPath->AppendL( id );

    mCollectionUtility->Collection().OpenL( *collectionPath );

    CleanupStack::PopAndDestroy( collectionPath );  

	mOpenCategoryAlbum = id;

	mCollectionPathLevel = VideoCollectionCommon::ELevelAlbum;

    mCollectionOpenStatus = ECollectionOpening;

}

// -----------------------------------------------------------------------------

// backL

// -----------------------------------------------------------------------------

//

void VideoCollectionClient::backL()

{

    if(!mCollectionUtility)

    {

        User::Leave(KErrGeneral);

    } 

    if (getCollectionLevel() > 2 )

    {

    	mCollectionUtility->Collection().BackL();

    	mCollectionOpenStatus = ECollectionOpening;

    	mOpenCategoryAlbum = TMPXItemId::InvalidId();

    	mCollectionPathLevel = VideoCollectionCommon::ELevelCategory;

    }

}

// -----------------------------------------------------------------------------

// getVideoDetailsL

// -----------------------------------------------------------------------------

//

void VideoCollectionClient::getVideoDetailsL(TMPXItemId &videoId)

{

    if(!mCollectionUtility)

    {

        User::Leave(KErrGeneral);

    }

    CMPXCommand* cmd = CMPXCommand::NewL();

    CleanupStack::PushL( cmd );

    cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos );

    cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosGetMediaFullDetailsByMpxId );

    cmd->SetTObjectValueL( KMPXMediaGeneralId, videoId );

    mCollectionUtility->Collection().CommandL( *cmd );

    CleanupStack::PopAndDestroy( cmd );  

}

// -----------------------------------------------------------------------------

// removeAlbumsL

// -----------------------------------------------------------------------------

//

void VideoCollectionClient::removeAlbumsL(const QList<TMPXItemId> &mediaIds)

{

    if(!mCollectionUtility)

    {

        User::Leave(KErrGeneral);

    }

    CMPXCommand* cmd = CMPXCommand::NewL();

    CleanupStack::PushL( cmd );

    cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos );

    cmd->SetTObjectValueL(KVcxMediaMyVideosCommandId, KVcxCommandMyVideosRemoveAlbums);

    cmd->SetTObjectValueL(KMPXCommandGeneralDoSync, EFalse);

    cmd->SetTObjectValueL(KMPXCommandGeneralCollectionId, TUid::Uid(KVcxUidMyVideosMpxCollection));

    CMPXMediaArray* array = CMPXMediaArray::NewL();

    CleanupStack::PushL( array );

    CMPXMedia* media = 0;

    int count = mediaIds.count();

    for (int i = 0; i < count; i++)

    {

        if(mediaIds.at(i).iId2 == KVcxMvcMediaTypeAlbum)

        {

            media = CMPXMedia::NewL();

            CleanupStack::PushL(media);

            media->SetTObjectValueL(KMPXMediaGeneralId, mediaIds.at(i));

            array->AppendL(*media);

            CleanupStack::PopAndDestroy(media);

        }

    }

    if(array->Count())