/*

* Copyright (c) 2008-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:    Implementation of collection manager API for external use

*

*/

#include "glxcollectionmanagerimpl.h"

#include <glxcommandfactory.h>

#include <glxpanic.h>

#include <mpxcollectionmessage.h>

#include <mpxcollectionpath.h>

#include <mpxcollectionutility.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediageneraldefs.h>

#include <mpxmessagegeneraldefs.h>

#include "glxcollectioninfo.h"

#include <glxcollectionplugincamera.hrh>

#include <glxcollectionpluginalbums.hrh>

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

// Constructor

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

//

CGlxCollectionManagerImpl::CGlxCollectionManagerImpl()

    {

    }

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

// Destructor

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

//

CGlxCollectionManagerImpl::~CGlxCollectionManagerImpl()

    {

    CloseCollection();

    delete iUri;

    }

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

// CGlxCollectionManagerImpl::AddToContainerL

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

//

void CGlxCollectionManagerImpl::AddToContainerL(const TDesC& aUri, 

		CGlxCollectionManager::TCollection aContainer, TRequestStatus& aRequestStatus)

    {

    __ASSERT_DEBUG(CGlxCollectionManager::ECollectionCameraAlbum == aContainer, Panic(EGlxPanicUnsupportedCollection));

    iCollectionId.iUid = KGlxCollectionPluginCameraImplementationUid;

    iContainerId = 0; // A zero container id indicates to the data source that we wish to the 

    // 'special album' related to the collection id. e.g. the camera album.

    AddToContainerL(aUri,aRequestStatus);

    }

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

// CGlxCollectionManagerImpl::AddToContainerL

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

//

void CGlxCollectionManagerImpl::AddToContainerL(const TDesC& aUri, 

                        TUint32 aCollectionId, TRequestStatus& aRequestStatus)

    {

    iCollectionId.iUid = KGlxCollectionPluginAlbumsImplementationUid;

    iContainerId = aCollectionId;

    AddToContainerL(aUri,aRequestStatus);

    }

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

// CGlxCollectionManagerImpl::CollectionInfoL

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

//

void CGlxCollectionManagerImpl::CollectionInfoL(CGlxCollectionInfo& aInfo,

                        TRequestStatus& aRequestStatus)

    {

    __ASSERT_DEBUG(iState == EClosed || iState == EOpen, Panic(EGlxPanicIllegalState));

    iCollectionInfo = &aInfo;

    InitializeRequest(aRequestStatus);

    if (iState == EOpen)

    	{

    	CloseCollection(); // Close and re-open the collection to ensure we have the

    	                   // latest changes.

    	}

    iState = EOpeningForCollectionInfo;

    OpenCollectionL();

    }

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

// CGlxCollectionManagerImpl::Cancel

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

//

void CGlxCollectionManagerImpl::Cancel()

    {	

    ///@todo test canceling

    switch (iState)

    	{

    	case EClosed:

    	case EOpen:

    	case EOpening:

    		{

    		// no request outstanding

    		break;

    		}

    	case EOpeningForAdd:

    	case EOpeningForCollectionInfo:

    		{

    		iState = EOpening; // Complete open if we can.

    		break;		

    		}

    	case EAdding:

    	case ERequestingMedia:

    		{

    		iState = EOpen;

    		iCollectionUtility->Collection().CancelRequest();

    		}

    	}

    CompleteRequest(KErrCancel);

    }

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

// CGlxCollectionManagerImpl::HandleCollectionMessageL

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

//

void CGlxCollectionManagerImpl::HandleCollectionMessageL(const TMPXCollectionMessage& /*aMessage*/)

    {

    // Don't do anything.

    }

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

// CGlxCollectionManagerImpl::HandleCollectionMessageL

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

//

void CGlxCollectionManagerImpl::HandleCollectionMessageL(const CMPXMessage& aMsg)

    {

    if (aMsg.IsSupported(KMPXMessageGeneralEvent))

    	{

	    switch (aMsg.ValueTObjectL<TInt>(KMPXMessageGeneralEvent))

	    	{

	    	case TMPXCollectionMessage::EPathChanged:

	    		{

	            __ASSERT_DEBUG(iState == EOpeningForAdd || iState == EOpeningForCollectionInfo || iState == EOpening || iState == EOpen, Panic(EGlxPanicIllegalState));

	            TState oldState = iState;

	            iState = EOpen;

	            switch(oldState)

	            {

	            case EOpeningForAdd:

	            	{

	            	iState = EOpen;

	            	DoAddToContainerL();

	            	break;

	            	}

	            case EOpeningForCollectionInfo:

	            	{

	        		iState = EOpen;

	            	__ASSERT_DEBUG(iCollectionInfo, Panic(EGlxPanicNullPointer));

	        		DoCollectionInfoL();

	        		break;

	            	}

	            case EOpening:

	            	{

	            	// don't do anything

	            	break;

	            	}

		    		}

	    		}

	    	break;

	    	default:

	    	break;

	    	}

    	}

    }

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

// CGlxCollectionManagerImpl::HandleOpenL

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

//

void CGlxCollectionManagerImpl::HandleOpenL(const CMPXMedia& /*aEntries*/,

                         TInt /*aIndex*/,TBool /*aComplete*/,TInt aError)

    { 

    // Handle open only gets called when an error occurs

    ///@todo check that this method works

    __ASSERT_DEBUG(iState == EOpening || iState == EOpeningForAdd || iState == EOpeningForCollectionInfo, Panic(EGlxPanicIllegalState));

    if (aError != KErrNone)

    	{

    	CompleteRequest(aError);

    	iState = EClosed;

    	}  	

    }

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

// CGlxCollectionManagerImpl::HandleOpenL

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

//

void CGlxCollectionManagerImpl::HandleOpenL(const CMPXCollectionPlaylist& /*aPlaylist*/ ,TInt /*aError*/)

    {

    // Don't do anything.

    }

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

// CGlxCollectionManagerImpl::HandleCollectionMediaL

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

//

void CGlxCollectionManagerImpl::HandleCollectionMediaL(const CMPXMedia& aMedia, TInt aError)

    {

    iState = EOpen;    	

    if (aError == KErrNone && iCollectionInfo)

    	{

        iCollectionInfo->SetExists(ETrue);

        iCollectionInfo->SetTitleL(aMedia.ValueText(KMPXMediaGeneralTitle));

    	}

    CompleteRequest(aError);

    }

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

// CGlxCollectionManagerImpl::HandleCommandComplete

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

//

void CGlxCollectionManagerImpl::HandleCommandComplete(CMPXCommand* /*aCommandResult*/, TInt aError)

    {

    CompleteRequest(aError);

    iState = EOpen;

    }

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

// CGlxCollectionManagerImpl::CompleteRequest

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

//

void CGlxCollectionManagerImpl::CompleteRequest(TInt aError)

    {

    if (iRequestStatus)

        {

        User::RequestComplete(iRequestStatus, aError);

        iRequestStatus = NULL;

        }

    }

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

// CGlxCollectionManagerImpl::InitializeRequest

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

//

void CGlxCollectionManagerImpl::InitializeRequest(TRequestStatus& aRequestStatus)

    {

    __ASSERT_DEBUG(!iRequestStatus, Panic(EGlxPanicCollectionManagerOutstandingRequest));

    iRequestStatus = &aRequestStatus;

    *iRequestStatus = KRequestPending;

    }

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

// CGlxCollectionManagerImpl::OpenCollectionL

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

//

void CGlxCollectionManagerImpl::OpenCollectionL()

    {

    if (iCollectionUtility)

    	{

    	iCollectionUtility->Close(); // deletes the collection utility's this pointer. 

    	}

    iCollectionUtility = NULL;

    iCollectionUtility = MMPXCollectionUtility::NewL(this);

	CMPXCollectionPath* path = CMPXCollectionPath::NewL();

    CleanupStack::PushL(path);

	path->AppendL(KGlxCollectionPluginAlbumsImplementationUid); //Open the albums collection plugin

	// We can use this plugin to add things to the camera album.

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

	CleanupStack::PopAndDestroy(path);

    }

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

// CGlxCollectionManagerImpl::CloseCollection

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

//

void CGlxCollectionManagerImpl::CloseCollection()

	{

	if (iCollectionUtility)

		{

		iCollectionUtility->Close();

		iCollectionUtility = NULL;

		}

	iState = EClosed;

	}

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

// CGlxCollectionManagerImpl::DoAddToContainerL

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

//

void CGlxCollectionManagerImpl::DoAddToContainerL()

	{

	__ASSERT_DEBUG(iState == EOpen, Panic(EGlxPanicIllegalState));

	CMPXCollectionPath* targetContainerPath = CMPXCollectionPath::NewL();

    CleanupStack::PushL(targetContainerPath);

    targetContainerPath->AppendL(iCollectionId.iUid);

    targetContainerPath->AppendL(iContainerId);

    CMPXCommand* command = TGlxCommandFactory::AddToContainerCommandLC(*iUri, *targetContainerPath);

    CleanupStack::Pop(command);

    CleanupStack::PopAndDestroy(targetContainerPath);

    CleanupStack::PushL(command);

    iCollectionUtility->Collection().CommandL(*command);

    CleanupStack::PopAndDestroy(command);

    iState = EAdding;

	}

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

// CGlxCollectionManagerImpl::AddToContainerL

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

//

void CGlxCollectionManagerImpl::AddToContainerL(const TDesC& aUri, TRequestStatus& aRequestStatus)

	{

    __ASSERT_DEBUG(iState == EClosed || iState == EOpen,  Panic(EGlxPanicIllegalState));

    InitializeRequest(aRequestStatus);

	delete iUri;

    iUri = NULL;

    iUri = aUri.AllocL();

    if (iState == EClosed)

    	{

    	iState = EOpeningForAdd;

    	OpenCollectionL();

    	}

    else

    	{

    	DoAddToContainerL();

    	}

	}

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

// CGlxCollectionManagerImpl::DoCollectionInfoL

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

//

void CGlxCollectionManagerImpl::DoCollectionInfoL()

	{

    __ASSERT_DEBUG(iState == EOpen,  Panic(EGlxPanicIllegalState));

	CMPXCollectionPath* path = iCollectionUtility->Collection().PathL();

	CleanupStack::PushL(path);

	TInt index = path->IndexOfId(iCollectionInfo->Id());

	if (index == KErrNotFound)

		{

		iCollectionInfo->SetExists(EFalse);

		CompleteRequest(KErrNone);

		}

	else if(index < 0) // Index is an error other than KErrNotFound

		{

		CompleteRequest(index);

		}

	else

		{

		// the index is good get the title

		path->Set(index);

		RArray<TMPXAttribute> attributeArray;

		CleanupClosePushL(attributeArray);

		attributeArray.AppendL(KMPXMediaGeneralTitle);

		iCollectionUtility->Collection().MediaL(*path, attributeArray.Array());

		CleanupStack::PopAndDestroy(&attributeArray);

		iState = ERequestingMedia;

		}

	CleanupStack::PopAndDestroy(path);

	}