/*
* Copyright (c) 2010 Ixonos Plc.
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the "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:
* Ixonos Plc
*
* Description:  
*
*/


/* Copyright (c) 2003, Nokia. All rights reserved */

#include "AudClipInfo.h"
#include "AudProcessor.h"
#include "AudPanic.h"



#include <fbs.h>
#include <e32base.h>

// Debug print macro
#if defined _DEBUG 
#include <e32svr.h>
#define PRINT(x) RDebug::Print x;
#else
#define PRINT(x)
#endif


EXPORT_C CAudClipInfo* CAudClipInfo::NewL(const TDesC& aFileName, 
                                          MAudClipInfoObserver& aObserver)
    {
    CAudClipInfo* self = NewLC(aFileName, aObserver);
    CleanupStack::Pop(self);
    return self;
    }

    
EXPORT_C CAudClipInfo* CAudClipInfo::NewLC(const TDesC& aFileName, 
                                           MAudClipInfoObserver& aObserver)
    {
    CAudClipInfo* self = new (ELeave) CAudClipInfo();
    CleanupStack::PushL(self);
    self->ConstructL(aFileName, aObserver);
    return self;
    }
    
EXPORT_C CAudClipInfo* CAudClipInfo::NewL(RFile* aFileHandle,
                                          MAudClipInfoObserver& aObserver)
    {
    CAudClipInfo* self = NewLC(aFileHandle, aObserver);
    CleanupStack::Pop(self);
    return self;
    }

    
EXPORT_C CAudClipInfo* CAudClipInfo::NewLC(RFile* aFileHandle,
                                           MAudClipInfoObserver& aObserver)
    {
    CAudClipInfo* self = new (ELeave) CAudClipInfo();
    CleanupStack::PushL(self);
    self->ConstructL(aFileHandle, aObserver);
    return self;
    }

EXPORT_C TAudFileProperties CAudClipInfo::Properties() const
    {

    return *iProperties;
    }

EXPORT_C TPtrC CAudClipInfo::FileName() const 
    {
    return *iFileName;
    }
    
EXPORT_C RFile* CAudClipInfo::FileHandle() const 
    {
    return iFileHandle;
    }

EXPORT_C void CAudClipInfo::GetVisualizationL(MAudVisualizationObserver& aObserver,
                                              TInt aSize, TInt aPriority) const 
    {


    iOperation->StartVisualizationL(aObserver, aSize, aPriority);
    }

EXPORT_C void CAudClipInfo::CancelVisualization()
    {


    iOperation->CancelVisualization();
    }

CAudClipInfo::CAudClipInfo() : iInfoReady(EFalse)

    {
    }


void CAudClipInfo::ConstructL(const TDesC& aFileName, MAudClipInfoObserver& aObserver)
    {

    iProperties = new (ELeave) TAudFileProperties();

    iFileName = HBufC::NewL(aFileName.Length());
    *iFileName = aFileName;
    iFileHandle = NULL;
    
    iOperation = CAudClipInfoOperation::NewL(this, aObserver);
    iOperation->StartGetPropertiesL();

    }
    
void CAudClipInfo::ConstructL(RFile* aFileHandle, MAudClipInfoObserver& aObserver)
    {

    iProperties = new (ELeave) TAudFileProperties();
        
    iFileHandle = aFileHandle;
    
    iFileName = HBufC::NewL(1);
    
    iOperation = CAudClipInfoOperation::NewL(this, aObserver);
    iOperation->StartGetPropertiesL();

    }


EXPORT_C CAudClipInfo::~CAudClipInfo() 
    {
    
	PRINT((_L("CAudClipInfo::~CAudClipInfo() in")));
    if (iProperties != 0)
        {
        delete iProperties;
        iProperties = 0;
        }
	PRINT((_L("CAudClipInfo::~CAudClipInfo() deleted iProperties")));
    if (iOperation)
        {
        delete iOperation;
        iOperation = 0;
        }

	PRINT((_L("CAudClipInfo::~CAudClipInfo() deleted iOperation")));
    if (iFileName != 0)
        {
        delete iFileName;
        iFileName = 0;
        }
	PRINT((_L("CAudClipInfo::~CAudClipInfo() out")));
    
    }




CAudClipInfoOperation* CAudClipInfoOperation::NewL(CAudClipInfo* aInfo,
                                                             MAudClipInfoObserver& aObserver)
    {
    CAudClipInfoOperation* self = 
        new (ELeave) CAudClipInfoOperation(aInfo, aObserver);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }


CAudClipInfoOperation::CAudClipInfoOperation(CAudClipInfo* aInfo,
                                             MAudClipInfoObserver& aObserver) : 
                                             iInfo(aInfo), iObserver(&aObserver)
                                    
    {

    }


void CAudClipInfoOperation::ConstructL() 
    {

   
    }


CAudClipInfoOperation::~CAudClipInfoOperation() 
    {

	PRINT((_L("CAudClipInfoOperation::~CAudClipInfoOperation() in")));
    if (iProcessor != 0)
        {
        delete iProcessor;
        iProcessor = 0;

        }
	PRINT((_L("CAudClipInfoOperation::~CAudClipInfoOperation() out")));

    }


void CAudClipInfoOperation::NotifyClipInfoReady(TInt aError) 
    {
    
	PRINT((_L("CAudClipInfoOperation::NotifyClipInfoReady() in")));
    
    iInfo->iInfoReady = ETrue;

    if (iProcessor == 0) 
        {
        TAudPanic::Panic(TAudPanic::EInternal);
        }

    if (iProcessor != 0)
        {
        delete iProcessor;
        iProcessor = 0;
        }

    iObserver->NotifyClipInfoReady(*iInfo, aError);

	PRINT((_L("CAudClipInfoOperation::NotifyClipInfoReady() out")));

    }

void CAudClipInfoOperation::StartGetPropertiesL() 
    {
	PRINT((_L("CAudClipInfoOperation::StartGetPropertiesL() in")));

    if (iProcessor != 0) 
        {
        TAudPanic::Panic(TAudPanic::EInternal);
        }
    iProcessor = CAudProcessor::NewL();        
    iProcessor->GetAudFilePropertiesL(*iInfo->iFileName, iInfo->iFileHandle, 
                                      iInfo->iProperties, *this, CActive::EPriorityStandard);

	PRINT((_L("CAudClipInfoOperation::StartGetPropertiesL() out")));
    }

void CAudClipInfoOperation::StartVisualizationL(MAudVisualizationObserver& aObserver, TInt aSize, 
                                            TInt aPriority) 
    {

    if (iProcessor != 0) 
        {
        TAudPanic::Panic(TAudPanic::EClipInfoProcessAlreadyRunning);
        }
    iVisualizationObserver = &aObserver;

    CAudProcessor* processor = CAudProcessor::NewLC();
    
    processor->StartGetClipVisualizationL(iInfo, aSize, *this, aPriority);

    
    CleanupStack::Pop(processor);
    iProcessor = processor;

    }

void CAudClipInfoOperation::CancelVisualization()
    {
    PRINT((_L("CAudClipInfoOperation::CancelVisualization() in")));

    if (iProcessor == 0) 
        {
        PRINT((_L("CAudClipInfoOperation::CancelVisualization() no visualization going on, ignore")));
        return;
        }
    else 
        {
        PRINT((_L("CAudClipInfoOperation::CancelVisualization() cancel iProcessor")));
        iProcessor->CancelClipVisualization();
        
        delete iProcessor;
        iProcessor = 0;
            
        iVisualizationObserver = 0;
        PRINT((_L("CAudClipInfoOperation::CancelVisualization() out")));
        }
    }

void CAudClipInfoOperation::NotifySongVisualizationCompleted(const CAudSong& /*aSong*/, 
        TInt /*aError*/, 
        TInt8* /*aVisualization*/,
        TInt /*aSize*/) 
    {

    // should not be called
    TAudPanic::Panic(TAudPanic::EInternal);


    }

void CAudClipInfoOperation::NotifySongVisualizationStarted(const CAudSong& /*aSong*/, 
                                                                    TInt /*aError*/) 
    {
    // should not be called
    TAudPanic::Panic(TAudPanic::EInternal);

    }


void CAudClipInfoOperation::NotifySongVisualizationProgressed(const CAudSong& /*aSong*/, 
                                                                       TInt /*aPercentage*/) 
    {

    // should not be called
    TAudPanic::Panic(TAudPanic::EInternal);
    

    }

void CAudClipInfoOperation::NotifyClipInfoVisualizationCompleted(const CAudClipInfo& aClipInfo, 
        TInt aError, 
        TInt8* aVisualization,
        TInt aSize) 
    {
    PRINT((_L("CAudClipInfoOperation::NotifyClipInfoVisualizationCompleted() in")));
    if (aError != KErrNone)
        {
        iVisualizationObserver->NotifyClipInfoVisualizationCompleted(aClipInfo, aError, aVisualization, aSize);
        PRINT((_L("CAudClipInfoOperation::NotifyClipInfoVisualizationCompleted() completed with error %d"),aError));
        }
    else
        {
        if (iProcessor != 0)
            {
            delete iProcessor;
            iProcessor = 0;
            }

        MAudVisualizationObserver* observer = iVisualizationObserver;
        iVisualizationObserver = 0;
        observer->NotifyClipInfoVisualizationProgressed(aClipInfo, 100);
        observer->NotifyClipInfoVisualizationCompleted(aClipInfo, aError, aVisualization, aSize);
        PRINT((_L("CAudClipInfoOperation::NotifyClipInfoVisualizationCompleted() completed")));
        }
    
    
    PRINT((_L("CAudClipInfoOperation::NotifyClipInfoVisualizationCompleted() out")));
    }


void CAudClipInfoOperation::NotifyClipInfoVisualizationStarted(const CAudClipInfo& aClipInfo, 
                                        TInt aError) 
    {

    
    iVisualizationObserver->NotifyClipInfoVisualizationStarted(aClipInfo, aError);

    }

void CAudClipInfoOperation::NotifyClipInfoVisualizationProgressed(const CAudClipInfo& aClipInfo, 
                                                                           TInt aPercentage) 
    {

    
    iVisualizationObserver->NotifyClipInfoVisualizationProgressed(aClipInfo, aPercentage);
    }