/*

* Copyright (c) 2007 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:  This is the implementation of the CCallAudioControlImpl class.

*

*/

// INCLUDE FILES

#include "CallAudioControlImpl.h"

#include "CallAudioControlUtility.h"

#include "CallAudioControlProperty.h"

#include "CallAudioControlRepository.h"

#include "CallAudioControlCommon.h"

#ifdef __SERIES60_31__

#include <features.hrh>

#include <FeatMgr.h>

#include <MediatorDomainUIDs.h>

#include <e32property.h>

#include <KPhEngConstants.h>

_LIT(KPhoneCltExDllName, "PhoneClientExt.dll");

#endif

// -----------------------------------------------------------------------------

// CCCallAudioControlImpl::NewL

//

// -----------------------------------------------------------------------------

//

CCallAudioControlImpl* CCallAudioControlImpl::NewL()

    {

    CCallAudioControlImpl* self = new (ELeave) CCallAudioControlImpl();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// -----------------------------------------------------------------------------

// CCallAudioControlImpl::CCallAudioControlImpl

// C++ constructor.

// -----------------------------------------------------------------------------

//

CCallAudioControlImpl::CCallAudioControlImpl()

    {

    }

// -----------------------------------------------------------------------------

// CCallAudioControlImpl::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CCallAudioControlImpl::ConstructL()

{

	CAC_TRACE1(_L("CCallAudioControlImpl::ConstructL enter"));

#ifdef __WINS__

	iWinsTesting = ETrue;

#endif

	//Create objects for data base access (both Central Repository and Publish and Subscribe):

	iCsNotifier = CCallAudioControlProperty::NewL(this, KUidCallInfo, KTelephonyCallState, ECallState );

#ifdef __SERIES60_31__

	CAC_TRACE1(_L("CCallAudioControlImpl::ConstructL Creating CMediatorCommandInitiator for 3.1 "));

    iCommandInitiator = CMediatorCommandInitiator::NewL( this );

    iMuteNotifier = CCallAudioControlProperty::NewL(this,KUidSystemCategory, KUidMute.iUid, EMute);

#else

    CAC_TRACE1(_L("CCallAudioControlImpl::ConstructL Creating CPhoneClient for non 3.1 "));

    iPhoneClient = CPhCltCommandHandler::NewL();

    iMuteNotifier = CCallAudioControlProperty::NewL(this,KUidMute, KTelephonyMute, EMute);

#endif

	iIhfVolumeNotifier = CCallAudioControlRepository::NewL(this,KUidVolume, KTelephonyIHFVolume, EIHFVolume);

	iEpVolumeNotifier = CCallAudioControlRepository::NewL(this, KUidVolume, KTelephonyEPVolume, EEPVolume);

    // Get current call state and is it active:

    TBool active = IsCallActive();

	CAC_TRACE2(_L("CCallAudioControl: Current Call State: %d"),iCallState);

   	// If in active call create TAR, get current audio output routing and

   	// get volume (based on audio routing) and set iVolume:

	if (active)

	{

        CAC_TRACE1(_L("CCallAudioControl: Active Call: Setting iVolume, etc..."));

		iTelephonyAudioRouting = CTelephonyAudioRouting::NewL(*this);

		iCurrentAudioOutput = (CCallAudioControl::TAudioOutput)iTelephonyAudioRouting->Output();

		TInt error = GetVolume();

	}

	else // Otherwise, get EP volume and set iVolume = EPVolume

	{

   		TInt error = iEpVolumeNotifier->Get(iVolume);

   		CAC_TRACE2(_L("CCallAudioControl: Not active call, setting iVolume to EPVolume = %d"),iVolume);

	}

	// Subscribe for call state changes:

	// if CAC is created before an active call, then we need to subscribe to Telephony notifications whenever the

	// the call is active, so that CAC can create TAR for audio routing

   	iCsNotifier->Subscribe();

	CAC_TRACE1(_L("CCallAudioControlImpl::ConstructL exit"));

}

// -----------------------------------------------------------------------------

// CCallAudioControlImpl::DestructL

// Destructor

// -----------------------------------------------------------------------------

//

CCallAudioControlImpl::~CCallAudioControlImpl()

    {

	CAC_TRACE2(_L("CCallAudioControlImpl[%x]::~AudioOutputControlImpl enter"),this);

    // Empty arrays:

    iRoutingObservers.Reset();

    iDownlinkVolumeObservers.Reset();

  	iUplinkGainObservers.Reset();

	CAC_TRACE2(_L("~CAudioOutputControlImpl: Deleting Volume Notifiers..."),this);

	delete iEpVolumeNotifier;

	delete iIhfVolumeNotifier;

	CAC_TRACE2(_L("~CAudioOutputControlImpl: Deleting Call State Notifier..."),this);

	delete iCsNotifier;

	CAC_TRACE2(_L("~CAudioOutputControlImpl: Deleting Mute Notifier..."),this);

	delete iMuteNotifier;

	CAC_TRACE2(_L("~CAudioOutputControlImpl: Deleting TAR..."),this);

	delete iTelephonyAudioRouting;

#ifdef __SERIES60_31__

    CAC_TRACE2(_L("~CAudioOutputControlImpl: Deleting iCommandInitiator (3.1 ONLY)..."),this);

    delete iCommandInitiator;

#else

	CAC_TRACE2(_L("~CAudioOutputControlImpl: Deleting iPhoneClient..."),this);

	delete iPhoneClient;

#endif

	CAC_TRACE2(_L("CCallAudioControlImpl[%x]::~AudioOutputControlImpl exit"),this);

    }

// ---------------------------------------------------------

// CCallAudioControlImpl::AppendRoutingObserver

// ?implementation_description

// (other items were commented in a header).

// ---------------------------------------------------------

//

TInt CCallAudioControlImpl::AppendRoutingObserver(CRoutingObserver& aObserver)

    {

	CAC_TRACE2(_L("CCallAudioControlImpl[%x]::AppendRoutingObserver enter"),this);

	// Return with error if it's already in list:

	for( TInt i = 0; i < iRoutingObservers.Count(); i++ )

   	{

        if ( iRoutingObservers[i] == &aObserver )

       	{

			CAC_TRACE1(_L("AppendRoutingObserver ERROR: Already Exists"));

            return KErrAlreadyExists;

      	}

 	}

	iRoutingObservers.Append(&aObserver);

	CAC_TRACE2(_L("CCallAudioControlImpl[%x]::AppendRoutingObserver exit"),this);

	return KErrNone;

    }

// ---------------------------------------------------------

// CCallAudioControlImpl::RemoveRoutingObserver

// ?implementation_description

// (other items were commented in a header).

// ---------------------------------------------------------

//

TInt CCallAudioControlImpl::RemoveRoutingObserver(CRoutingObserver& aObserver)

    {

	CAC_TRACE2(_L("CCallAudioControlImpl[%x]::RemoveRoutingObserver enter"),this);

	TInt error(KErrNotFound);

	for( TInt i = 0; i < iRoutingObservers.Count(); i++ )

   	{

        if ( iRoutingObservers[i] == &aObserver )

       	{

            iRoutingObservers.Remove(i);

            error = KErrNone;

            break;

      	}

 	}

	CAC_TRACE3(_L("CCallAudioControlImpl[%x]::RemoveRoutingObserver exit with error: %d"),this, error);

	return error;

    }

// ---------------------------------------------------------

// CCallAudioControlImpl::AppendDownlinkVolumeObserver

// ?implementation_description

// (other items were commented in a header).

// ---------------------------------------------------------

//

TInt CCallAudioControlImpl::AppendDownlinkVolumeObserver(CDownlinkVolumeObserver& aObserver)

{

	CAC_TRACE2(_L("CCallAudioControlImpl[%x]::AppendDownlinkVolumeObserver enter"),this);

	// Return with error if it's already in list:

	for( TInt i = 0; i < iDownlinkVolumeObservers.Count(); i++ )

   	{

        if ( iDownlinkVolumeObservers[i] == &aObserver )

       	{

			CAC_TRACE1(_L("AppendDownlinkVolumeObserver ERROR: Already Exists"));

            return KErrAlreadyExists;

      	}

 	}

	iDownlinkVolumeObservers.Append(&aObserver);

	CAC_TRACE2(_L("CCallAudioControlImpl[%x]::AppendDownlinkVolumeObserver exit"),this);

	return KErrNone;

}

// ---------------------------------------------------------

// CCallAudioControlImpl::RemoveDownlinkVolumeObserver

// ?implementation_description

// (other items were commented in a header).

// ---------------------------------------------------------

//

TInt CCallAudioControlImpl::RemoveDownlinkVolumeObserver(CDownlinkVolumeObserver& aObserver)

    {

	CAC_TRACE2(_L("CCallAudioControlImpl[%x]::RemoveDownlinkVolumeObserver enter"),this);

	TInt error(KErrNotFound);

	for( TInt i = 0; i < iDownlinkVolumeObservers.Count(); i++ )

   	{

        if ( iDownlinkVolumeObservers[i] == &aObserver )

       	{

            iDownlinkVolumeObservers.Remove(i);

            error = KErrNone;

      	}

 	}

	CAC_TRACE3(_L("CCallAudioControlImpl[%x]::RemoveDownlinkVolumeObserver exit with error: %d"),this, error);

	return error;

    }

// ---------------------------------------------------------

// CCallAudioControlImpl::AppendUplinkGainObserver

// ?implementation_description

// (other items were commented in a header).

// ---------------------------------------------------------

//

TInt CCallAudioControlImpl::AppendUplinkGainObserver(CUplinkGainObserver& aObserver)

    {

	CAC_TRACE2(_L("CCallAudioControlImpl[%x]::AppendUplinkGainObserver enter"),this);

	TInt error(KErrNone);

	// Return with error if it's already in list:

	for( TInt i = 0; i < iUplinkGainObservers.Count(); i++ )

   	{

        if ( iUplinkGainObservers[i] == &aObserver )

       	{

			CAC_TRACE1(_L("AppendUplinkGainObserver ERROR: Already Exists"));

            return KErrAlreadyExists;

      	}

 	}

	error = iUplinkGainObservers.Append(&aObserver);

    if (error == KErrNone)

    {

   		iMuteNotifier->Subscribe();

    }

	CAC_TRACE3(_L("CCallAudioControlImpl[%x]::AppendUplinkGainObserver Error [%d] exit"),this, error);

    return error;

    }

// ---------------------------------------------------------

// CCallAudioControlImpl::RemoveUplinkGainObserver

// ?implementation_description

// (other items were commented in a header).

// ---------------------------------------------------------

//

TInt CCallAudioControlImpl::RemoveUplinkGainObserver(CUplinkGainObserver& aObserver)

{

	CAC_TRACE2(_L("CCallAudioControlImpl[%x]RemoveUplinkGainObserver enter"),this);

	TInt error(KErrNotFound);

	for( TInt i = 0; i < iUplinkGainObservers.Count(); i++ )

   	{

        if ( iUplinkGainObservers[i] == &aObserver )

       	{

            iUplinkGainObservers.Remove(i);

            error = KErrNone;

      	}

 	}

 	// Unsubscribe for mute updates if list is empty and currently subscribed

 	if ( !iUplinkGainObservers.Count() )

 	{

		iMuteNotifier->Unsubscribe();

 	}

	CAC_TRACE3(_L("CCallAudioControlImpl[%x]::RemoveUplinkGainObserver exit with error: %d"),this, error);

 	return error;

}

// ---------------------------------------------------------

// CCallAudioControlImpl::GetAvaliableOutputs

// ?implementation_description

// (other items were commented in a header).

// ---------------------------------------------------------

//

TInt CCallAudioControlImpl::GetAvailableOutputs(RArray<CCallAudioControl::TAudioOutput>& aAvailableOutputs)

{

	CAC_TRACE2(_L("CCallAudioControlImpl[%x]::GetAvailableOutputs enter"),this);

    TInt error(KErrNone);

    CCallAudioControl::TAudioOutput arrayElement;

    TBool active = IsCallActive();

   	if (active)

    {

    	if (!iTelephonyAudioRouting)

    	{

            CAC_TRACE1(_L("CCallAudioControlImpl[%x]::GetAvailableOutputs TAR not available "));

            return KErrCompletion;

    	}

		TArray<CTelephonyAudioRouting::TAudioOutput> availableOutputArray = iTelephonyAudioRouting->AvailableOutputs();

		TInt arrayCount = availableOutputArray.Count();

 		for (TInt i = 0; i < arrayCount; i++)

  		{

       		CAC_TRACE3(_L("AvailableOutput[%d] = %d"), i, availableOutputArray[i]);

       		arrayElement = (CCallAudioControl::TAudioOutput)(availableOutputArray[i]);

      		aAvailableOutputs.Append(arrayElement);

   		}

    }

    else

    	error = KErrPermissionDenied;

	CAC_TRACE3(_L("CCallAudioControlImpl[%x]::GetAvailableOutputs exit with error: %d"),this, error);

    return error;

}

// ---------------------------------------------------------

// CCallAudioControlImpl::GetOutput

// ?implementation_description

// (other items were commented in a header).

// ---------------------------------------------------------

//

TInt CCallAudioControlImpl::GetOutput(CCallAudioControl::TAudioOutput& aOutput)

{

	CAC_TRACE2(_L("CCallAudioControlImpl[%x]::GetOutput enter"),this);

	TInt error(KErrNone);

    TBool active = IsCallActive();

   	if (active)

    {

    	if (!iTelephonyAudioRouting)

    	{

            CAC_TRACE1(_L("CCallAudioControlImpl[%x]::GetOutput TAR not available "));

            return KErrCompletion;

    	}

 		aOutput = (CCallAudioControl::TAudioOutput)(iTelephonyAudioRouting->Output());

 		iCurrentAudioOutput = aOutput;

		CAC_TRACE2(_L("GetOutput: Output retrieved: %d"),aOutput);

    }

    else

    	error = KErrPermissionDenied;

	CAC_TRACE3(_L("CCallAudioControlImpl[%x]::GetOutput exit with error: %d"),this, error);

    return error;

}

// ---------------------------------------------------------

// CCallAudioControlImpl::::SetOutput

// ?implementation_description

// (other items were commented in a header).

// ---------------------------------------------------------

//

TInt CCallAudioControlImpl::SetOutput(CCallAudioControl::TAudioOutput aOutput)

{

	CAC_TRACE3(_L("CCallAudioControlImpl[%x]::SetOutput with: %d"),this, aOutput);

    TInt error(KErrNone);

    TBool active = IsCallActive();

   	if (active)

    {

    	if (!iTelephonyAudioRouting)

    	{

            CAC_TRACE1(_L("CCallAudioControlImpl[%x]::SetOutput TAR not available "));

            return KErrCompletion;

    	}

    	if ((aOutput == CTelephonyAudioRouting::ENone) || (aOutput == CTelephonyAudioRouting::ENotActive))

    	{

    		return (KErrArgument);

    	}

		TRAP(error,iTelephonyAudioRouting->SetOutputL((CTelephonyAudioRouting::TAudioOutput)aOutput));

    }

    else

    {

		error = KErrPermissionDenied;

    }

	CAC_TRACE3(_L("CCallAudioControlImpl[%x]::SetOutput exit with error: %d"),this, error);

    return error;

}

// ---------------------------------------------------------

// CCallAudioControlImpl::::PreviousOutput

// ?implementation_description

// (other items were commented in a header).

// ---------------------------------------------------------

//

TInt CCallAudioControlImpl::PreviousOutput(CCallAudioControl::TAudioOutput& aPreviousOutput)

{

	CAC_TRACE2(_L("CCallAudioControlImpl[%x]::PreviousOutput enter"),this);

    TInt error(KErrNone);

    TBool active = IsCallActive();

   	if (active)

    {

    	if (!iTelephonyAudioRouting)

    	{

            CAC_TRACE1(_L("CCallAudioControlImpl[%x]::PreviousOutput TAR not available "));

            return KErrCompletion;

    	}

		aPreviousOutput = (CCallAudioControl::TAudioOutput)iTelephonyAudioRouting->PreviousOutput();

    }

    else

    {

    	error = KErrPermissionDenied;

    }

	CAC_TRACE3(_L("CCallAudioControlImpl[%x]::PreviousOutput exit with error: %d"),this, error);

    return error;

}

// ---------------------------------------------------------

// CCallAudioControlImpl::GetMinDownlinkVolume

// ?implementation_description

// (other items were commented in a header).

// ---------------------------------------------------------

//

TInt CCallAudioControlImpl::GetMinDownlinkVolume(TUint& aVolume)

    {

	CAC_TRACE2(_L("CCallAudioControlImpl[%x]::GetMinDownlinkVolume"),this);

    // Hard-coded to 0:

    aVolume = KMinVolume;

    return KErrNone;

    }

// ---------------------------------------------------------

// CCallAudioControlImpl::GetDownlinkVolume

// ?implementation_description

// (other items were commented in a header).

// ---------------------------------------------------------

//

TInt CCallAudioControlImpl::GetDownlinkVolume(TUint& aVolume)

    {

	CAC_TRACE3(_L("CCallAudioControlImpl[%x]::GetDownlinkVolume will return: iVolume"),this, iVolume);

	TInt error(KErrNone);

	if (iVolume < 0) // An error occurred while getting iVolume form DBase prior

	{

		error = iVolume; // return error to client

	}

	else

	{

    	aVolume = iVolume;

	}

    return error;

    }

// ---------------------------------------------------------

// CCallAudioControlImpl::GetMaxDownlinkVolume

// ?implementation_description

// (other items were commented in a header).

// ---------------------------------------------------------

//

TInt CCallAudioControlImpl::GetMaxDownlinkVolume(TUint& aVolume)

    {

	CAC_TRACE2(_L("CCallAudioControlImpl[%x]::GetMaxDownlinkVolume"),this);

    // Hard-coded to 10:

    aVolume = KMaxVolume;

    return KErrNone;

    }

// ---------------------------------------------------------

// CCallAudioControlImpl::SetDownlinkVolume

// ?implementation_description

// (other items were commented in a header).

// ---------------------------------------------------------

//

TInt CCallAudioControlImpl::SetDownlinkVolume(TUint aVolume)

    {

	CAC_TRACE3(_L("CCallAudioControlImpl[%x]::SetDownlinkVolume to: %d"),this, aVolume);

	TInt newVolume = 0;

    // Verify OK to set volume, which is only allowed during an

    // active call and if audio routing is appropriate:

    TInt error = CheckIfOkToSetVolume();

    if (error != KErrNone)

    {

	CAC_TRACE2(_L("SetDownlinkVolume: ERROR: %d"), error);

   	return error;

    }

    // Make sure aVolume range is valid and set newVolume:

    newVolume = VerifyAndSetVolume(aVolume);

    TUint currVol;

    RETURN_IF_ERROR(GetDownlinkVolume(currVol));

    if (currVol !=  aVolume)

        {

        // Update correct volume key, based on current audio routing:

        if ( (iCurrentAudioOutput == CTelephonyAudioRouting::EHandset) || (iCurrentAudioOutput == CTelephonyAudioRouting::EWiredAudioAccessory))

        {

            error = iEpVolumeNotifier->Set(newVolume);

            iPendingEpVolLevelOp = ETrue;

            iRequestedEpVolLevel = aVolume;

        }

        else if (iCurrentAudioOutput == CTelephonyAudioRouting::ELoudspeaker)

        {

            error = iIhfVolumeNotifier->Set(newVolume);

            iPendingIhfVolLevelOp = ETrue;

            iRequestedIhfVolLevel = aVolume;

        }

        else

            error = KErrArgument; // invalid iCurrentAudioOutput value

        }

	CAC_TRACE3(_L("CCallAudioControlImpl[%x]::SetDownlinkVolume exit with error: %d"),this, error);

    return error;

    }

// ---------------------------------------------------------

// CCallAudioControlImpl::GetUplinkMute

// ?implementation_description

// (other items were commented in a header).

// ---------------------------------------------------------

//

TInt CCallAudioControlImpl::GetUplinkMute(TBool& aMute)

{

	CAC_TRACE2(_L("CCallAudioControlImpl[%x]::GetUplinkMute enter"),this);

   	TInt error = iMuteNotifier->Get(aMute);

   	RETURN_IF_ERROR(error);

#ifdef __SERIES60_31__

    if (aMute == EPSMicMuteOn)

        aMute = ETrue;

    else if ((aMute == EPSMicMuteOff) || (aMute == EPSMicMuteStateUninitialized))

        aMute = EFalse;

    else

        error = KErrUnknown;

#else

    /* 3.2 and beyond: */

    /* 3.2 also appears to be an enum defined in s60/app/telephony/inc/KPhEngConstants.h

     * Check with component owner */

    #ifndef __SERIES60_32__ /* 5.0 and beyond */