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

    	}

    else if(iDevAudio->iActiveState != EDevSoundAdaptorPaused_Primed)

        {

        DP0_RET(KErrNotReady, "%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);

        }

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

    DP_OUT();

    }

void CDevCommonControl::ContextEventStateDevSoundAdaptorBeingPreempted() // from CDevCommonControl

    {

    DP_CONTEXT(CDevCommonControl::ContextEventStateDevSoundAdaptorBeingPreempted, 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::ContextEventStateDevSoundAdaptorUninitializing, 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::ContextEventErrorStateDevSoundAdaptorActivating, 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::ContextEventErrorStateDevSoundAdaptorBeingPreempted, CtxDevSound, DPLOCAL);

    DP_IN();

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

    FinishWithError(KErrInUse);

    if(iIgnoreAsyncOpComplete)

        {

        iAdaptationObserver->PreemptionFinishedCallbackReceived(ETrue);

        }

    DP_OUT();

    }

void CDevCommonControl::ContextEventUpdateWithoutStateEventNoError() // from CDevCommonControl

    {

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

    DP2_IN("iActiveState=%d iIgnoreAsyncOpComplete=%d",iDevAudio->iActiveState, iIgnoreAsyncOpComplete);

    if (iDevAudio->iActiveState != EDevSoundAdaptorRemovingProcessingUnits)

        {

	    if (iIgnoreAsyncOpComplete)

	      {

	      iAdaptationObserver->PreemptionFinishedCallbackReceived(ETrue);

	      iIgnoreAsyncOpComplete = EFalse;

	      }

	    else

	      {

	      iAdaptationObserver->AsynchronousOperationComplete(KErrNone, ETrue);

	      }

        DP_OUT();

        return;

        }

    //If the Commit cycle when going into EDevSoundAdaptorRemovingProcessingUnits fails due to pre-emption

    //clash then we re-apply the client request again.

    if (iDevAudio->iActiveState == EDevSoundAdaptorRemovingProcessingUnits && iIgnoreAsyncOpComplete)

    	{

		//Pop front of queue to re-apply the request again via CMMFDevSoundSession::DequeueRequest

		//from the callback into CMMFDevSoundSession below:

		iAdaptationObserver->PreemptionFinishedCallbackReceived(ETrue);

		iIgnoreAsyncOpComplete = EFalse;

		DP_OUT();

		return;

    	}

    iDevAudio->iActiveState = EDevSoundAdaptorCreated_Uninitialised;

    if (iDevAudio->iReinitializing)

        {

        ContextEventStopDevSoundNotifications();

        TInt err = iDevAudio->Initialize(iDevAudio->iTargetFormat, iDevAudio->iTargetMode);

        if(err)

            {

            ContextEventAsynchronousInitializeComplete(err);

            }

        iDevAudio->iReinitializing = EFalse;

        DP_OUT();

        return;

        }

    iDevAudio->iClosing = EFalse;

    iAdaptationObserver->AsynchronousOperationComplete(KErrNone, ETrue);

    DP_OUT();

    }

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

    {

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

    DP_IN();

    //If flag is true below then it must be due to a stateless normal pre-emption or

    //stateless pre-emption clash scenario.

    if(iIgnoreAsyncOpComplete)

    	{

		//If we are in pre-emption clash then callback below will retry the client request again.

		iAdaptationObserver->PreemptionFinishedCallbackReceived(ETrue); // notify client of end of cycle

		iIgnoreAsyncOpComplete = EFalse;

    	}

    else

    	{

        TDevSoundAdaptorState previousState = iDevAudio->iPreviousState;

        DP3(DLINFO,"Error with no state change, state %d, previous %d, error %d during Commit cycle",

                    iDevAudio->iActiveState, previousState, aError);

        // We can end up here for a number of reasons. For non "mid states", this is

        // a standard error scenario. For some mid-states (e.g. Activating, Loading etc),

        // when we try and "promote" the state, this happens when the promotion is rejected

        // and we handle thus accordingly. For other mid-states the situation is less clear

        // and we call AsynchronousOperationComplete() with the error assuming the parent

        // session will deal with it. Whatever we don't want to stay in a mid-state, so

        // rewind to the previous ("normal") one if we are in one.

        // Longer term TODO. If the code were refactored so that the InitializeComplete(),

        // PlayError() etc callback came from AsynchronousOperationComplete() then the

        // following code might be simpler. Most of the time (at least) we get here because

        // we are doing a session function, and we can use the function to determine what

        // to do more easily than relying on the state. As it is, for some mid-states we

        // try and work out what error code to generate. Not clear this covers 100% cases,

        // although demotion transitions should not fail, so the problem cases might not occur.

        //

		//If we reach this condition then it is because of rejection/error during Commit cycle.

		switch (iDevAudio->iActiveState)

			{

			case EDevSoundAdaptorInitialising:

				{

				iDevAudio->iActiveState = previousState;

				ContextEventAsynchronousInitializeComplete(aError);

				break;

				}

			case EDevSoundAdaptorLoading:

				{

				iDevAudio->iActiveState = previousState;

				ContextEventAsynchronousPlayCompletion(aError);

				break;

				}

			case EDevSoundAdaptorActivating:

				{

				iDevAudio->iActiveState = previousState;

				ContextEventAsynchronousPlayCompletion(aError);

				break;

				}

			case EDevSoundAdaptorRemovingProcessingUnits:

			case EDevSoundAdaptorUninitialising:

			case EDevSoundAdaptorUnloading:

			case EDevSoundAdaptorStopping:

			case EDevSoundAdaptorPausing:

			    {

                DP2(DLINFO,"Unexpected mid state [%d] when handling error [%d] during Commit cycle, workback", iDevAudio->iActiveState, aError);

			    iDevAudio->iActiveState = previousState;

                iAdaptationObserver->AsynchronousOperationComplete(aError, ETrue);

			    break;

			    }

			default:

				{

				DP2(DLINFO,"Unexpected state [%d] when handling error [%d] during Commit cycle", iDevAudio->iActiveState, aError);

		        iAdaptationObserver->AsynchronousOperationComplete(aError, ETrue);

				}

			}

    	}

    DP_OUT();

    }

void CDevCommonControl::ContextEventUpdateWithStateEventNoError() // from CDevCommonControl 

    {

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

    DP_IN();

    switch (iDevAudio->iActiveState)

        {

    case EDevSoundAdaptorUninitialising:

        iDevAudio->iActiveState = EDevSoundAdaptorUnitialised_Uninitialised;

        ContextEventStateDevSoundAdaptorUninitializing();

        break;

    case EDevSoundAdaptorInitialising:

        iDevAudio->iActiveState = EDevSoundAdaptorInitialised_Initialised;

        ContextEventAsynchronousInitializeComplete(KErrNone);

        break;

    case EDevSoundAdaptorUnloading:

        iDevAudio->iActiveState = EDevSoundAdaptorInitialised_Initialised;

        ContextEventStateDevSoundAdaptorUnloading();

        break;

    case EDevSoundAdaptorLoading:

        iDevAudio->iActiveState = EDevSoundAdaptorGoingActive;

        ContextEventStateDevSoundAdaptorLoading();

        break;

    case EDevSoundAdaptorStopping:

        iDevAudio->iActiveState = EDevSoundAdaptorInitialised_Idle;

        ContextEventStateDevSoundAdaptorStopping();

        break;

    case EDevSoundAdaptorActivating:

        iDevAudio->iActiveState = EDevSoundAdaptorActive_Active;

        ContextEventPauseResumeSequenceDueToEmptyBuffers(EFalse);

        break;

    case EDevSoundAdaptorPausing:

        iDevAudio->iActiveState = EDevSoundAdaptorPaused_Primed;

        ContextEventPauseResumeSequenceDueToEmptyBuffers(ETrue);

        break;

    case EDevSoundAdaptorBeingPreempted:

        iDevAudio->iActiveState = EDevSoundAdaptorInitialised_Initialised;

        ContextEventStateDevSoundAdaptorBeingPreempted();

        break;

    default:

        break;

        }   

    DP_OUT();

    }

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

    {

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

    DP_IN();

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

    switch(iDevAudio->iActiveState)

        {

    case EDevSoundAdaptorInitialising:

        iDevAudio->iActiveState = EDevSoundAdaptorCreated_Uninitialised;

        iAdaptationObserver->InitializeComplete(aError);

        break;

    case EDevSoundAdaptorLoading:

        iDevAudio->iActiveState = EDevSoundAdaptorInitialised_Initialised;

        FinishWithError(aError);

        break;

    case EDevSoundAdaptorActivating:

        iDevAudio->iActiveState = EDevSoundAdaptorInitialised_Idle;

        ContextEventErrorStateDevSoundAdaptorActivating(aError);

        break;

    case EDevSoundAdaptorBeingPreempted:

        iDevAudio->iActiveState = EDevSoundAdaptorInitialised_Initialised;

        ContextEventErrorStateDevSoundAdaptorBeingPreempted();

        break;

    default:

        break;

        }

    iCallbackFromAdaptor = KCallbackNone;

    if(!iIgnoreAsyncOpComplete)

        {

        iAdaptationObserver->AsynchronousOperationComplete(aError, ETrue);

        }

    else

        {

        iAdaptationObserver->PreemptionFinishedCallbackReceived(ETrue);

        iIgnoreAsyncOpComplete=EFalse;

        }

    DP_OUT();

    }

// end of file