// 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:

//

#include "cdevcommoncontrol.h"

#include <a3f/maudiocontext.h> 

#include <a3f/maudiocodec.h>

CDevCommonControl::CDevCommonControl()

    {

    TRACE_CREATE();

    DP_CONTEXT(CDevCommonControl::CDevCommonControl, CtxDevSound, DPLOCAL);

    DP_IN();

    DP_OUT();

    }

CDevCommonControl::~CDevCommonControl()

    {

    DP_CONTEXT(CDevCommonControl::~CDevCommonControl, CtxDevSound, DPLOCAL);

    DP_IN();

    DP_OUT();

    }

TInt CDevCommonControl::Stop() // from CDevAudioControl

    {

    DP_CONTEXT(CDevCommonControl::Stop, CtxDevSound, DPLOCAL);

    DP_IN();

    TInt err = KErrNone;

    switch(iDevAudio->iActiveState)

        {

        case EDevSoundAdaptorActive_Active:

        case EDevSoundAdaptorPaused_Primed:

            err = iDevAudio->iAudioStream->Stop();

            if (err == KErrNone)

                {

                err = iDevAudio->CommitAudioContext();

                }

            if (err == KErrNone)

                {

                iDevAudio->iActiveState = EDevSoundAdaptorStopping;

                }

            break;

        case EDevSoundAdaptorGoingActive:

            iDevAudio->iActiveState = EDevSoundAdaptorStopping;

            break;

        case EDevSoundAdaptorInitialised_Idle:

        	{

        	//If following condition is true, then we are here because of a

        	//pre-emption clash in last Commit cycle started from

        	//CDevCommonControl::ContextEventUpdateWithStateEventNoError.

        	if(iDevAudio->iPreviousState == EDevSoundAdaptorUnloading)

        		{

				err = Unload();

				break;

        		}

        	}

        default:

            break;

        }

    if(err == KErrNone)

        {

        iDevAudio->iStop = ETrue;

        }

    DP0_RET(err,"%d");

    }

TInt CDevCommonControl::Pause() // from CDevAudioControl

    {

    DP_CONTEXT(CDevCommonControl::Pause, CtxDevSound, DPLOCAL);

    DP_IN();

    TInt err = iDevAudio->iAudioStream->Prime();

    if ( err == KErrNone)

        {

        err = iDevAudio->CommitAudioContext();

        }

    if (err == KErrNone)

        {

        iDevAudio->iActiveState = EDevSoundAdaptorPausing;

        }

    DP0_RET(err,"%d");

    }

TInt CDevCommonControl::Resume() // from CDevAudioControl

    {

    DP_CONTEXT(CDevCommonControl::Resume, CtxDevSound, DPLOCAL);

    DP_IN();

    TInt err = KErrNone;

    //If following condition is true, then we are here because of a

    //pre-emption clash in last Commit cycle started from

    //CDevCommonControl::ContextEventUpdateWithStateEventAndError.

    if(iDevAudio->iActiveState == EDevSoundAdaptorInitialised_Idle &&

    		iDevAudio->iPreviousState == EDevSoundAdaptorUnloading)

    	{

		err = Unload();

		DP0_RET(err,"%d");

    	}

    if(err == KErrNone)

        {

        // Populate gain and balance values set in the Paused state and being cached

        err = iDevAudio->RequestGainAndBalance(this);

        }

    if(err == KErrNone)

        {

        err = iDevAudio->iAudioStream->Activate();

        }

    if ( err == KErrNone)

        {

        err = iDevAudio->CommitAudioContext();

        }

    if (err == KErrNone)

        {

        iDevAudio->iActiveState = EDevSoundAdaptorActivating;

        }

    DP0_RET(err,"%d");

    }

void CDevCommonControl::StateEvent(MAudioStream& aStream, TInt aError,  // from MAudioProcessingUnitObserver

                                    TAudioState aNewState)

    {

    DP_CONTEXT(CDevCommonControl::StateEvent, CtxDevSound, DPLOCAL);

    DP3_IN("activeState %d -> newstate %d, (%d)",

            iDevAudio->iActiveState, aNewState, aError);

    __ASSERT_ALWAYS(iDevAudio->iAudioStream == &aStream, Panic(EStreamMismatch));

    if(aError != KErrNone || iDevAudio->iActiveStreamState != aNewState) 

        {

        iDevAudio->iActiveStreamState = aNewState;

        iStateEventReceived = ETrue;

        }

    // Since the audiostream already demoted the state for the most of the cases

    // only is need  when a error comes were the stream was at the middle of A3f two-phase transition

    else

        {

        switch (aNewState)

            {

            case EIdle:

                // Demote the stream state

                iDevAudio->iActiveStreamState = EIdle;

                break;

            default:

                break;

            }

        }

    iStateEventError = aError;

    DP_OUT();

    }

void CDevCommonControl::ProcessingUnitError(MAudioProcessingUnit* /*aInstance*/, // from MAudioProcessingUnitObserver

                                                                 TInt aError)

    {

    DP_CONTEXT(CDevCommonControl::ProcessingUnitError, CtxDevSound, DPLOCAL);

    DP_IN();

    if(iCallbackFromAdaptor == KCallbackNone)   

        {

        iProcessingUnitError = aError;

        iCallbackFromAdaptor = KCallbackProcessingUnitError;

        iAdaptationObserver->CallbackFromAdaptorReceived(KCallbackProcessingUnitError, aError);

        }

    else

        {

        // Multiple callbacks from adaptor

        DP0(DLINFO, "Multiple callbacks from adaptor");

        }

    DP_OUT();

    }

void CDevCommonControl::ContextEvent(TUid aEvent, TInt aError) 

    {

    DP_CONTEXT(CDevCommonControl::ContextEvent, CtxDevSound, DPLOCAL);

    DP3_IN("ContextEvent aEvent=%x iActiveState=%d aError=%d",aEvent, iDevAudio->iActiveState, aError);

    // Can't "switch {...}" on UIDs unfortunately:

    if (aEvent == KUidA3FContextUpdateComplete)

        {

        if(iBeingPreempted)

            {

			if(iStateEventReceived)

				{

				//use a sub state pattern to make pre-emption cycles like other cycles.

				DP1(DLERR,"Preemption error=%d", aError);

				iDevAudio->iActiveState = EDevSoundAdaptorBeingPreempted;

				if(iPreemptionClash)

					{

					// remove last request from front of queue without processing it

					iAdaptationObserver->PreemptionClashWithStateChange();

					iPreemptionClash=EFalse;

					}

				}

            else if(!iStateEventReceived && iPreemptionClash)

        		{

				iIgnoreAsyncOpComplete=ETrue;

				iPreemptionClash=EFalse;

        		}

			iBeingPreempted=EFalse;

            }

		ContextEventUpdateComplete(aError);

        }

    else if ((aEvent == KUidA3FContextCommitUpdate))

        {

        iBeingPreempted=EFalse; // clear being preempted

        iPreemptionClash=EFalse; // clear pre-emption clash flag

        TBool adaptorControlsContext = iAdaptationObserver->AdaptorControlsContext();

        iIgnoreAsyncOpComplete = !adaptorControlsContext;

            // if we don't control context, always send a PreemptionFinishedCallbackReceived()

		iStateEventReceived=EFalse;

        }

    else if (aEvent == KUidA3FContextPreEmption)

        {

        // clear iBeingPreepted - will be set in ContextEventPreEmption if req

        iBeingPreempted=EFalse;

        iPreemptionClash=EFalse; // clear pre-emption clash flag

        TBool adaptorControlsContext = iAdaptationObserver->AdaptorControlsContext();

		iStateEventReceived=EFalse;

        iIgnoreAsyncOpComplete=EFalse; // clear being iIgnoreAsyncOpComplete

        ContextEventPreEmption(aEvent, aError);

        if (!adaptorControlsContext)

            {

            iIgnoreAsyncOpComplete = ETrue; // if we don't control context never do AsyncOpComplete

            }

        }

    else if (aEvent == KUidA3FContextPreEmptedCommit)

        {

		DP0(DLINFO,"KUidA3FContextPreEmptedCommit event received, thus clash with Pre-emption");

        // clear iBeingPreepted - will be set in ContextEventPreEmption if req

        iBeingPreempted=EFalse;

        TBool adaptorControlsContext = iAdaptationObserver->AdaptorControlsContext();

        if (adaptorControlsContext)

        	{

			// push current request that was being processed onto front of queue.

        	iAdaptationObserver->PreemptionClash();

        	iPreemptionClash=ETrue;

        	}

		iStateEventReceived=EFalse;

        iIgnoreAsyncOpComplete=EFalse; // clear being iIgnoreAsyncOpComplete

        ContextEventPreEmption(aEvent, aError);

        if (!adaptorControlsContext)

            {

            iIgnoreAsyncOpComplete = ETrue; // if we don't control context never do AsyncOpComplete

            }

        }

    else if (aEvent == KUidA3FContextAbort)

        {

        ContextEventAbort(aError);

        }

    DP_OUT();

    }

void CDevCommonControl::ContextEventAsynchronousPlayCompletion(TInt aError) // from CDevCommonControl

    {

    DP_CONTEXT(CDevCommonControl::ContextEventAsynchronousPlayCompletion, CtxDevSound, DPLOCAL);

    DP_IN();

	iAdaptationObserver->AsynchronousOperationComplete(aError, ETrue);

    if (aError)

        {

        FinishWithError(aError);

        }

    DP_OUT();

    }

void CDevCommonControl::ContextEventAsynchronousInitializeComplete(TInt aError) // from CDevCommonControl

    {

    DP_CONTEXT(CDevCommonControl::ContextEventAsynchronousInitializeComplete, CtxDevSound, DPLOCAL);

    DP_IN();

    iAdaptationObserver->AsynchronousOperationComplete(aError, ETrue);

    iAdaptationObserver->InitializeComplete(aError);

    DP_OUT();

    }

void CDevCommonControl::ContextEventUpdateComplete(TInt aError) // from CDevCommonControl

    {

    DP_CONTEXT(CDevCommonControl::ContextEventUpdateComplete, CtxDevSound, DPLOCAL);

    DP_IN();

    if (iStateEventReceived)

        {

        iStateEventReceived = EFalse;

        DP0(DLINFO,"Context event for that does involve state change");         

        if (aError)

            {

            ContextEventUpdateWithStateEventAndError(aError);

            }

        else

            {

            ContextEventUpdateWithStateEventNoError();

            }   

        DP_OUT();

        return;

        }

    DP0(DLINFO,"Context event for that doesn't involve state change");

    if (aError)

        {

        ContextEventUpdateWithoutStateEventButWithError(aError);

        }

    else

        {

        ContextEventUpdateWithoutStateEventNoError();

        }

    DP_OUT();

    }

void CDevCommonControl::ContextEventPreEmption(TUid aEvent, TInt aError) // from CDevCommonControl

    {

    DP_CONTEXT(CDevCommonControl::ContextEventPreEmption, CtxDevSound, DPLOCAL);

    DP_IN();

    DP1(DLERR,"Preemption error=%d", aError);

    CDevAudioControl::ContextEvent(aEvent, aError);

    iBeingPreempted=ETrue;

    DP_OUT();

    }

void CDevCommonControl::ContextEventAbort(TInt aError) // from CDevCommonControl

    {

    DP_CONTEXT(CDevCommonControl::ContextEventAbort, CtxDevSound, DPLOCAL);

    DP_IN();

    DP1(DLERR,"Abort error=%d", aError);

    FinishWithError(aError==KErrAbort ? KErrDied:aError);

    DP_OUT();

    }

void CDevCommonControl::ContextEventStopDevSoundNotifications() // from CDevCommonControl

    {

    DP_CONTEXT(CDevCommonControl::ContextEventStopDevSoundNotifications, CtxDevSound, DPLOCAL);

    DP_IN();

    iDevAudio->iAudioStream->UnregisterAudioStreamObserver(*this);

    iGainControl->UnregisterAudioGainControlObserver(*this);

    iAudioCodecIf->UnregisterAudioCodecObserver(*this);

    iAudioCodecIf = NULL;

    DP_OUT();

    }

void CDevCommonControl::ContextEventPauseResumeSequenceDueToEmptyBuffers(TBool aFlush) // from CDevCommonControl

    {

    DP_CONTEXT(CDevCommonControl::ContextEventPauseResumeSequenceDueToEmptyBuffers, CtxDevSound, DPLOCAL);

    DP_IN();

    TInt err(KErrNone);

    if (iPauseResumeSequenceDueToEmptyBuffers)

        {

        if (aFlush)

            {

            err = iDevAudio->iAudioStream->Flush();

            }

        if ((err) or (aFlush==EFalse))

            {

            iPauseResumeSequenceDueToEmptyBuffers = EFalse;

            iAdaptationObserver->CallbackFromAdaptorReceived(KCallbackFlushComplete, err);

            }

        }

    else

        {

        iAdaptationObserver->AsynchronousOperationComplete(KErrNone, ETrue);    

        }

    DP_OUT();

    }

void CDevCommonControl::ContextEventStateDevSoundAdaptorUnloading() // from CDevCommonControl

    {

    DP_CONTEXT(CDevCommonControl::ContextEventStateDevSoundAdaptorUnloading, CtxDevSound, DPLOCAL);

    DP_IN();

    // Due destruction sequence or reinitialization

    if (iDevAudio->iClosing or iDevAudio->iReinitializing)

        {

        TInt err = Uninitialize();

        if (err and iDevAudio->iReinitializing)

            {

            ContextEventAsynchronousInitializeComplete(err);

            }

        DP_OUT();

        return;

        }

    // Notify the user that ProcessingFinished is complete. 

    // Stop call complete, sent callback.

    if (iCallbackFromAdaptor != KCallbackNone)

        {

        iAdaptationObserver->AsynchronousOperationComplete(KErrNone, ETrue);

        if (iCallbackFromAdaptor == KCallbackProcessingFinished)

            {

            FinishWithError(KErrUnderflow);

            }

        else if (iCallbackFromAdaptor == KCallbackProcessingUnitError)

            {

            FinishWithError(iProcessingUnitError);

            }

        iCallbackFromAdaptor = KCallbackNone;

        DP_OUT();

        return;

        }

    // Error condition

    if (iErrorCondition)

        {

        FinishWithError(iErrorCondition);

        iErrorCondition = KErrNone;

        }

    else

        {

        iAdaptationObserver->AsynchronousOperationComplete(KErrNone, ETrue);

        }

    DP_OUT();

    }

void CDevCommonControl::ContextEventStateDevSoundAdaptorLoading() // from CDevCommonControl

    {

    DP_CONTEXT(CDevCommonControl::ContextEventStateDevSoundAdaptorLoading, CtxDevSound, DPLOCAL);

    DP_IN();

    iDevAudio->RequestGainAndBalance(this); // TODO handle error

    TInt err = iDevAudio->iAudioStream->Activate();

    if (err)

        {

        DP_OUT();

        return;

        }

    err = iDevAudio->CommitAudioContext();

    if (err)

        {

        ContextEventAsynchronousPlayCompletion(err);

        DP_OUT();

        return;

        }

    iDevAudio->iActiveState = EDevSoundAdaptorActivating;

    iAdaptationObserver->AsynchronousOperationComplete(KErrNone, EFalse);

    DP_OUT();

    }

void CDevCommonControl::ContextEventStateDevSoundAdaptorStopping() // from CDevCommonControl

    {   

    DP_CONTEXT(CDevCommonControl::ContextEventStateDevSoundAdaptorStopping, CtxDevSound, DPLOCAL);

    DP_IN();

    TInt err = Unload();

    if (err)

        {

        DP0(DLINFO,"Commit failed during stopping");

        FinishWithError(err);

        }