/*

* Copyright (c) 2007 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 asynchronous operation

*  

   Copyright (c) 2007 Nokia Corporation.

*  This material, including documentation and any related 

*  computer programs, is protected by copyright controlled by 

*  Nokia Corporation. All rights are reserved. Copying, 

*  including reproducing, storing, adapting or translating, any 

*  or all of this material requires the prior written consent of 

*  Nokia Corporation. This material also contains confidential 

*  information which may not be disclosed to others without the 

*  prior written consent of Nokia Corporation.

* 

*

*/

#include "CamCollectionManagerAo.h"

#include <glxcollectionmanager.h>

#include <glxcollectioninfo.h>

#include "MCamAddToAlbumObserver.h"

#include "CamLogger.h"

#include "Cam.hrh"

#include "CamUtility.h"

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

// CCamCollectionManagerAO::CCamCollectionManagerAO()

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

//

CCamCollectionManagerAO::CCamCollectionManagerAO( MCamAddToAlbumObserver& aObserver )

:CActive(EPriorityStandard),iObserver(aObserver)

    {

    CActiveScheduler::Add(this);

    }

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

// CCamCollectionManagerAO::~CCamCollectionManagerAO()

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

//

CCamCollectionManagerAO::~CCamCollectionManagerAO()

    {

    Cancel();

    if ( iCollectionManager )

        {

        delete iCollectionManager;

        iCollectionManager = NULL;

        }

    if ( iCollectionInfo )

        {

        delete iCollectionInfo;

        iCollectionInfo = NULL;

        }

    iSelectedAlbumIds.Close();

    }

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

// CCamCollectionManagerAO::StartAddtoAlbumOperationL

//

// Initiates Callback Mechanism for adding Images/Videos to albums

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

//

void CCamCollectionManagerAO::StartCallBackAddToAlbumL(

                              const RArray<TUint32>& aSelectedAlbumIds, 

                              const TDesC& aUri 

                              )

    {

    PRINT( _L("Camera => CCamCollectionManagerAO::StartCallBackAddToAlbumL") );

    PRINT( _L("Camera <> CCamCollectionManagerAO::StartCallBackAddToAlbumL ... Calling CGlxCollectionManager::NewL()") );

    if (!iCollectionManager)

        {

        iCollectionManager = CGlxCollectionManager::NewL();

        }

    PRINT( _L("Camera <> CCamCollectionManagerAO::StartCallBackAddToAlbumL ... CGlxCollectionManager::NewL() Success ") );

    iUri = aUri;

    iSelectedAlbumIds.Reset();

    for ( TInt i = 0; i < aSelectedAlbumIds.Count(); i++ )

        {

        iSelectedAlbumIds.AppendL( aSelectedAlbumIds[i] );

        }

    iCurrentAlbumIndex = 0;

    PRINT( _L("Camera <> CCamCollectionManagerAO::StartCallBackAddToAlbumL ... Calling iCollectionManager->AddToCollectionL()") );

    iCollectionManager->AddToCollectionL(

                        aUri, 

    			        aSelectedAlbumIds[iCurrentAlbumIndex], 

    			        iStatus );

    PRINT( _L("Camera <> CCamCollectionManagerAO::StartCallBackAddToAlbumL ... iCollectionManager->AddToCollectionL() : Success") );

    iCurrentAlbumIndex++;

    iAddToAlbum = ETrue;

    SetActive();

    PRINT( _L("Camera <= CCamCollectionManagerAO::StartCallBackAddToAlbumL") );

    }

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

//  CCamCollectionManagerAO::CheckForAlbumExistenceL

//

//  Initiates Callback Mechanism for checking if the album really exists

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

//

void CCamCollectionManagerAO::CheckForAlbumExistenceL( 

                                       const TUint32 aDefaultAlbumId )

    {

    PRINT( _L("Camera => CCamCollectionManagerAO::CheckForAlbumExistenceL") );

    if (!iCollectionManager)

        {

        iCollectionManager = CGlxCollectionManager::NewL();

        }

    if ( iCollectionInfo )

        {

        delete iCollectionInfo;

        iCollectionInfo = NULL;

        }

    iCollectionInfo = CGlxCollectionInfo::NewL( aDefaultAlbumId );

    iCollectionManager->CollectionInfoL( *iCollectionInfo, iStatus );

    iCheckForAlbum = ETrue;

    SetActive();

    PRINT( _L("Camera <= CCamCollectionManagerAO::CheckForAlbumExistenceL") );

    }

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

// CCamCollectionManagerAO::RunL()

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

//

void CCamCollectionManagerAO::RunL()

    {

    PRINT( _L("Camera => CCamCollectionManagerAO::RunL") );

    if ( iAddToAlbum )

        {

        iAddToAlbum = EFalse;

        if ( iStatus.Int() == KErrNone)

    	    {

    	    PRINT( _L("Camera <> CCamCollectionManagerAO::RunL() Finalizing") );

            DoAddToAlbumOperationL();

    	    }

    	else

    	    {

    	    // if there is any error, we pass and handle there

    	    PRINT( _L("Camera <> CCamCollectionManagerAO::RunL() add to album has problems") );

    	    RunError( iStatus.Int() );

    	    }

        }

     else if ( iCheckForAlbum )

        {

        iCheckForAlbum = EFalse;

        if ( iStatus.Int() == KErrNone)

    	    {

            DoCheckAlbumOperationCompleteL();

    	    }

    	else

    	    {

    	    // if there is any error, we pass and handle there

    	    RunError( iStatus.Int() );

    	    }

        }

     else

        {

        // Handling special cases if any

        }

    PRINT( _L("Camera <= CCamCollectionManagerAO::RunL") );

    }

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

// CCamCollectionManagerAO::DoAddToAlbumOperationL()

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

//

void CCamCollectionManagerAO::DoAddToAlbumOperationL()

    {

    PRINT( _L("Camera => CCamCollectionManagerAO::DoAddToAlbumOperationL") );

    PRINT1( _L("Camera <> CCamCollectionManagerAO::DoAddToAlbumOperationL ... iCurrentAlbumIndex (%d)"), iCurrentAlbumIndex )

    PRINT1( _L("Camera <> CCamCollectionManagerAO::DoAddToAlbumOperationL ... iSelectedAlbumIds.Count() (%d)"), iSelectedAlbumIds.Count() )

	if ( iCurrentAlbumIndex < iSelectedAlbumIds.Count() )

        {

        PRINT( _L("Camera <> CCamCollectionManagerAO::DoAddToAlbumOperationL ... Enters If Loop") );

        iCollectionManager->AddToCollectionL(

                            iUri, 

    			            iSelectedAlbumIds[iCurrentAlbumIndex], 

    			            iStatus );

        iCurrentAlbumIndex++;

        iAddToAlbum = ETrue;

    	SetActive();

        }

    else

        {

        PRINT( _L("Camera <> CCamCollectionManagerAO::DoAddToAlbumOperationL ... Enters Else Loop") );

        iAddToAlbum = EFalse;

        iSelectedAlbumIds.Reset();

        iObserver.AddToAlbumIdOperationComplete();

        }

    PRINT1( _L("Camera <= CCamCollectionManagerAO::DoAddToAlbumOperationL ... Before leaving iCurrentAlbumIndex (%d)"), iCurrentAlbumIndex )

    }

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

// CCamCollectionManagerAO::CheckAlbumOperationComplete

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

//

void CCamCollectionManagerAO::DoCheckAlbumOperationCompleteL()

    {

    PRINT( _L("Camera => CCamCollectionManagerAO::DoCheckAlbumOperationCompleteL") );

    if ( iCollectionInfo )

        {

   	    iObserver.CheckAlbumIdOperationCompleteL( iCollectionInfo->Exists(),

    	                                          iCollectionInfo->Title() );

        }

    PRINT( _L("Camera <= CCamCollectionManagerAO::DoCheckAlbumOperationCompleteL") );

    }

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

// CCamCollectionManagerAO::DoCancel()

//

// Cancels the active object

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

//

void CCamCollectionManagerAO::DoCancel()

    {

    PRINT( _L("Camera => CCamCollectionManagerAO::DoCancel") );

    if ( iCollectionManager )

        {

        iCollectionManager->Cancel();

        }

    iSelectedAlbumIds.Reset();

    PRINT( _L("Camera <= CCamCollectionManagerAO::DoCancel") );

    }

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

// CCamCollectionManagerAO::RunError()

//

// Handles all leaves and its safe to handle them in this method

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

//

TInt CCamCollectionManagerAO::RunError( TInt /*aError*/ )

    {

    PRINT( _L("Camera => CCamCollectionManagerAO::RunError") );

    // We make sure that if any error occurs, we cancel,

    // the ongoing request and delete all the pointers

    // so that no memory leaks occurs

    if ( iCollectionManager )

        {

        delete iCollectionManager;

        iCollectionManager = NULL;

        }

    if ( iCollectionInfo )

        {

        delete iCollectionInfo;

        iCollectionManager = NULL;

        }

    iSelectedAlbumIds.Reset();

    PRINT( _L("Camera <= CCamCollectionManagerAO::RunError") );

    return KErrNone;

    }

//End of file