#include "AudioPlayerContainerView.h"
#include "AudioPlayerEngine.h"
const TInt KPlayerAdapterDefaultVolumeLevel(2);

CAudioPlayerEngine* CAudioPlayerEngine::NewL()
{
	CAudioPlayerEngine* self=CAudioPlayerEngine::NewLC();
	CleanupStack::Pop(self);
	return self;
	
}

CAudioPlayerEngine* CAudioPlayerEngine::NewLC()
{
	CAudioPlayerEngine* self=new(ELeave) CAudioPlayerEngine;
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
}

CLoudnessEffect* CLoudnessEffect::NewL(CMdaAudioPlayerUtility& aAudioPlayer,TBool aEnable)
{
	CLoudnessEffect* self=new(ELeave) CLoudnessEffect();
	CleanupStack::PushL(self);
	self->ConstructL(aAudioPlayer,aEnable);
	CleanupStack::Pop(self);
	return self;
}

CBassEffect* CBassEffect::NewL(CMdaAudioPlayerUtility& aAudioPlayer,TBool aEnable)
{
	CBassEffect* self=new(ELeave) CBassEffect();
	CleanupStack::PushL(self);
	self->ConstructL(aAudioPlayer,aEnable);
	CleanupStack::Pop(self);
	return self;
}

CStereoEffect* CStereoEffect::NewL(CMdaAudioPlayerUtility& aAudioPlayer,TBool aEnable)
{
	CStereoEffect* self=new(ELeave) CStereoEffect();
	CleanupStack::PushL(self);
	self->ConstructL(aAudioPlayer,aEnable);
	CleanupStack::Pop(self);
	return self;
}

CAudioPlayerEngine::CAudioPlayerEngine()
{
	
}

void CAudioPlayerEngine::ConstructL()
{
	iState=EIdle;
}

CAudioPlayerEngine::~CAudioPlayerEngine()
{
	Cleanup();
}

void CAudioPlayerEngine::Cleanup()
{
	if(iAudioPlayer)
	{
		iAudioPlayer->Stop();
		iAudioPlayer->Close();
		delete iAudioPlayer;
		iAudioPlayer=NULL;
		iState=EIdle;
	}
}

void CAudioPlayerEngine::PlayFileL(const TDesC16 &aFile)
{
	if (iState == EIdle)
	{
		
		
		iAudioPlayer = CMdaAudioPlayerUtility::NewFilePlayerL(aFile,*this);
		iState=EPlayFilePrepare;
	}
}

void CAudioPlayerEngine::StopFileL()
{
	if(iState==EPlayFilePlaying)
	{
		iAudioPlayer->Stop();
		iAudioPlayer->Close();
		iState=EIdle;
	}
}
void CAudioPlayerEngine::PauseL()
{
	if(iState==EPlayFilePlaying)
	{
		iAudioPlayer->Pause();
		iState=EPlayFilePrepare;
	}
}
void CAudioPlayerEngine::PlayL()
{
	if(iState==EPlayFilePrepare)
	{
		iAudioPlayer->Play();
		iState=EPlayFilePlaying;
	}
}
void CAudioPlayerEngine::MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds &aDuration)
{
	if (aError)
	{
		Cleanup();
		return;
	}
	
}

void CAudioPlayerEngine::MapcPlayComplete(TInt aError)
{
	Cleanup();
}

void CAudioPlayerEngine::SetVolume(TInt volume)
{
	if (iAudioPlayer)
	{
		iAudioPlayer->SetVolume(volume);
	}
}
void CAudioPlayerEngine::Volume()
{
	TInt volume = KPlayerAdapterDefaultVolumeLevel;
	if ( iAudioPlayer)
	{
		if( !iVolFactor )
		{
			TInt maxVol = iAudioPlayer->MaxVolume();
			
			iVolFactor=10.0/maxVol;
		}
		iAudioPlayer->GetVolume(volume);
		volume = (TInt)(iVolFactor*volume);
	};
	return ;
}
TInt CAudioPlayerEngine::Control(TInt ant)
{
	
	return ant;
}
TInt cnt;
void CAudioPlayerEngine::PlayPauseL()
{
	if(iState==EPlayFilePlaying)
	{
		PauseL();
	}
	else
		if(iState==EPlayFilePrepare)
		{
			PlayL();
		}
}

void CLoudnessEffect::ConstructL(CMdaAudioPlayerUtility& aAudioPlayer,TBool aEnable)
{
	iLoudnessEffect=CLoudness::NewL(aAudioPlayer,EFalse);
	iLoudnessEffect->RegisterObserverL(*this);
}

void CLoudnessEffect::EnableEffect()
{	
	iLoudnessEffect->RegisterObserverL(*this);
	iLoudnessEffect->EnableL();	
}

void CLoudnessEffect::DisableEffect()
{
	iLoudnessEffect->DisableL();
	//This should not be done here. What if the effect is enabled again ???
	//iLoudnessEffect->UnRegisterObserver(*this);
}

void CBassEffect::ConstructL(CMdaAudioPlayerUtility& aAudioPlayer,TBool aEnable)
{
	iBassEffect=CBassBoost::NewL(aAudioPlayer,EFalse);
	iBassEffect->RegisterObserverL(*this);
}

void CBassEffect::EnableEffect()
{
	iBassEffect->EnableL();	
}

void CBassEffect::DisableEffect()
{
	iBassEffect->DisableL();
	//This should not be done here. What if the effect is enabled again??
	//iBassEffect->UnRegisterObserver(*this);
}

void CStereoEffect::ConstructL(CMdaAudioPlayerUtility& aAudioPlayer,TBool aEnable)
{
	iStereoEffect=CStereoWidening::NewL(aAudioPlayer,EFalse);
	iStereoEffect->RegisterObserverL(*this);
}


TBool CStereoEffect::IsContinuousLevelSupported()
{
	return iStereoEffect->IsContinuousLevelSupported();
}

void CStereoEffect::SetStereoWideningLevelL(TUint8 aLevel)
{
	iStereoEffect->SetStereoWideningLevelL(aLevel);
}

TUint8 CStereoEffect::StereoWideningLevel()
{
	return iStereoEffect->StereoWideningLevel();
}

void CStereoEffect::EnableEffect()
{
	iStereoEffect->EnableL();
}

void CStereoEffect::DisableEffect()
{
	iStereoEffect->DisableL();
	//This should not be done here.
	//iStereoEffect->UnRegisterObserver(*iMAudioEffectObserver);
}
void CLoudnessEffect::ApplyL()
{
	iLoudnessEffect->ApplyL();
}

void CBassEffect::ApplyL()
{
	iBassEffect->ApplyL();
}

void CStereoEffect::ApplyL()
{
	iStereoEffect->ApplyL();
}

CLoudnessEffect::CLoudnessEffect()
{
	
}

CBassEffect::CBassEffect()
{
	
}

CLoudnessEffect::~CLoudnessEffect()
{
	iStereoEffect->UnRegisterObserver(*this);
	delete iLoudnessEffect;
	iLoudnessEffect = NULL;
}

CBassEffect::~CBassEffect()
{
	iStereoEffect->UnRegisterObserver(*this);
	delete iBassEffect;
	iBassEffect = NULL;
}

CStereoEffect::~CStereoEffect()
{
	iStereoEffect->UnRegisterObserver(*this);
	delete iStereoEffect;
	iStereoEffect = NULL;
}

void CBassEffect::EffectChanged(const CAudioEffect* aObservedEffect,TUint8 aEvent)
{
	
}

void CLoudnessEffect::EffectChanged(const CAudioEffect* aObservedEffect,TUint8 aEvent)
{
	
}