// 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->iAudioContext->Commit();

                }

            if (err == KErrNone)

                {

                iDevAudio->iActiveState = EDevSoundAdaptorStopping;

                }

            break;

        case EDevSoundAdaptorGoingActive:

            iDevAudio->iActiveState = EDevSoundAdaptorStopping;

            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->iAudioContext->Commit();

        }

    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(iDevAudio->iActiveState != EDevSoundAdaptorPaused_Primed)

        {

        err = KErrNotReady;

        }

    if(err == KErrNone)

        {

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

        }

    if ( err == KErrNone)

        {

        err = iDevAudio->iAudioContext->Commit();

        }

    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)   

        {

        iCallbackFromAdaptor = KCallbackProcessingUnitError;

        }

    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);

    DP_IN();

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

    if (aEvent == KUidA3FContextUpdateComplete)

        {

        //use a sub state pattern to make premtion cycles like other cycles.

        if(iBeingPreempted)

            {

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

            CDevAudioControl::ContextEvent(aEvent, aError);

            iDevAudio->iActiveState = EDevSoundAdaptorBeingPreempted;

            iBeingPreempted=EFalse;

            }

        ContextEventUpdateComplete(aError);

        }

    else if ((aEvent == KUidA3FContextPreEmption) or (aEvent == KUidA3FContextPreEmptedCommit))

        {

        //we are not being preemptied

        iBeingPreempted=EFalse;

        ContextEventPreEmption(aEvent, aError);

        }

    else if (aEvent == KUidA3FContextAbort)

        {

        ContextEventAbort(aError);

        }

    DP_OUT();

    }

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

    {

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

    DP_IN();

	iAdaptationObserver->AsynchronousOperationComplete(aError, ETrue);

    if (aError)

        {

        FinishWithError(aError);

        }

    DP_OUT();

    }

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

    {

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

    DP_IN();

    iAdaptationObserver->AsynchronousOperationComplete(aError, ETrue);

    iAdaptationObserver->InitializeComplete(aError);

    DP_OUT();

    }

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

    {

    DP_CONTEXT(CDevCommonControl::ContextEvent, 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::ContextEvent, 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::ContextEvent, 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::ContextEvent, 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::ContextEvent, 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::ContextEvent, 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::ContextEvent, CtxDevSound, DPLOCAL);

    DP_IN();

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

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

    if (err)

        {

        DP_OUT();

        return;

        }

    err = iDevAudio->iAudioContext->Commit();

    if (err)

        {

        ContextEventAsynchronousPlayCompletion(err);

        DP_OUT();

        return;

        }

    iDevAudio->iActiveState = EDevSoundAdaptorActivating;

    iAdaptationObserver->AsynchronousOperationComplete(KErrNone, EFalse);

    DP_OUT();

    }

void CDevCommonControl::ContextEventStateDevSoundAdaptorStopping() // from CDevCommonControl

    {   

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

    DP_IN();

    TInt err = Unload();

    if (err)

        {

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

        FinishWithError(err);

        }

    __ASSERT_DEBUG(err==KErrNone, Panic(ECommitFailedDuringStop));

    DP_OUT();

    }

void CDevCommonControl::ContextEventStateDevSoundAdaptorBeingPreempted() // from CDevCommonControl

    {

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

    DP_IN();

    __ASSERT_DEBUG(iDevAudio->iActiveStreamState == EInitialized, Panic(EStreamBeingDemotedToEIdle));

    FinishWithError(KErrInUse);

    if (iIgnoreAsyncOpComplete)

        {

        iAdaptationObserver->PreemptionFinishedCallbackReceived(ETrue);

        iIgnoreAsyncOpComplete=EFalse;

        DP_OUT();

        return;

        }

    ContextEventPauseResumeSequenceDueToEmptyBuffers(EFalse);

    DP_OUT();

    }

void CDevCommonControl::ContextEventStateDevSoundAdaptorUninitializing() // from CDevCommonControl

    {

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

    DP_IN();

    TInt err = RemoveProcessingUnits();

    if (err == KErrNone)

        {

        iDevAudio->iActiveState = EDevSoundAdaptorRemovingProcessingUnits;

        }

    else if (iDevAudio->iReinitializing)

        {

        ContextEventAsynchronousInitializeComplete(err);

        }

    DP_OUT();

    }

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

    {

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

    DP_IN();

    // If the resume operation fails as result of EmptyBuffers

    // Notify about operation complete through CallbackFromAdaptorReceived

    // and continue to allow client to receive PlayError()

    if (iPauseResumeSequenceDueToEmptyBuffers)

        {

        iPauseResumeSequenceDueToEmptyBuffers = EFalse;

        iAdaptationObserver->CallbackFromAdaptorReceived(KCallbackFlushComplete, KErrNone);

        }

    iErrorCondition = aError;

    TInt err = Unload();

    if (err)

        {

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

        FinishWithError(err);

        }

    __ASSERT_DEBUG(err==KErrNone, Panic(ECommitFailedDuringStop));

    DP_OUT();

    }

void CDevCommonControl::ContextEventErrorStateDevSoundAdaptorBeingPreempted() // from CDevCommonControl

    {

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

    DP_IN();

__ASSERT_DEBUG(iDevAudio->iActiveStreamState == EInitialized, Panic(EStreamBeingDemotedToEIdle));

    FinishWithError(KErrInUse);

    if(iIgnoreAsyncOpComplete)

        {

        iAdaptationObserver->PreemptionFinishedCallbackReceived(ETrue);

        }