// 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 <f32file.h>
#include <e32math.h>
#include "mmfAudioPolicyProxy.h"
#include "MmfAudioPolicyStart.h"
#include "MmfBase.hrh"
#include "MmfDevSoundInfo.h"
#include "MmfAudioPolicyServer.h"



EXPORT_C TInt RMMFAudioPolicyProxy::Open(RServer2& aPolicyServerHandle)
	{
	ASSERT(aPolicyServerHandle.Handle());
	
	// Server is already running and attempt to create a session
	// 4 message slots
	TInt err = CreateSession(aPolicyServerHandle, TVersion(KMMFAudioPolicyVersion,
													KMMFAudioPolicyMinorVersionNumber,
													KMMFAudioPolicyBuildVersionNumber));		
	return err;		
	}

EXPORT_C TInt RMMFAudioPolicyProxy::CreateServer(RServer2& aPolicyServerHandle)
	{
	TServerStart start(aPolicyServerHandle);
	TThreadFunction serverFunc = CMMFAudioPolicyServer::StartThread;
	RThread server;
	TInt err = server.Create(_L(""),serverFunc, KAudioPolicyServerStackSize,
							KAudioPolicyServerInitHeapSize, KAudioPolicyServerMaxHeapSize,
							&start, EOwnerProcess);
	if(err != KErrNone)
		{
		return err;
		}		
		// Synchronise with the server
	TRequestStatus reqStatus;
	server.Rendezvous(reqStatus);
	if (reqStatus!=KRequestPending)
		{
		server.Kill(0);
		}
	else 
		{
		// Start the test harness
		server.Resume();
		// Server will call the reciprocal static synchronise call
		}
	User::WaitForRequest(reqStatus); // wait for start or death
	server.Close();
	if(reqStatus.Int() != KErrNone)
		{
		return reqStatus.Int();
		}
	return err;		
	}

EXPORT_C TInt RMMFAudioPolicyProxy::SetDevSoundInfo(TMMFDevSoundInfo& aDevSoundInfo)
	{
	TMMFDevSoundInfoPckg psPckg(aDevSoundInfo);
	return SendReceive(EMMFPolicySetDevSoundInfo, psPckg);
	}

EXPORT_C void RMMFAudioPolicyProxy::MakeRequest(TMMFAudioPolicyPrioritySettings& aPrioritySettings)
	{
	iPsPckg().iState = aPrioritySettings.iState;
	iPsPckg().iPref = aPrioritySettings.iPref;
	iPsPckg().iPriority = aPrioritySettings.iPriority;
	iPsPckg().iCapabilities = aPrioritySettings.iCapabilities;
	SendReceive(EMMFPolicyMakeRequest, iPsPckg);
	}

EXPORT_C TInt RMMFAudioPolicyProxy::UpdateState(TMMFAudioPolicyPrioritySettings& aPrioritySettings)
	{
	TMMFAudioPolicyPrioritySettingsPckg psPckg(aPrioritySettings);
	return SendReceive(EMMFPolicyUpdateState, psPckg);
	}

EXPORT_C void RMMFAudioPolicyProxy::ReceiveEvents(TMMFAudioPolicyEventPckg& aEventPckg, TRequestStatus& aStatus)
	{
	SendReceiveResult(EMMFPolicyReceiveEvents, aEventPckg, aStatus);
	}

EXPORT_C TInt RMMFAudioPolicyProxy::CancelReceiveEvents()
	{
	return SendReceive(EMMFPolicyCancelReceiveEvents);
	}

EXPORT_C TInt RMMFAudioPolicyProxy::GetPlayFormatsSupported(RMdaDevSound::TSoundFormatsSupportedBuf& aPlayFormatsSupported) 
	{
	RMdaDevSound::TSoundFormatsSupportedBuf playFormatsSupported;
	TInt err = SendReceiveResult(EMMFPolicyGetPlayFormatsSupported, playFormatsSupported);
	if (!err)
		aPlayFormatsSupported = playFormatsSupported;
	return  err;
	}

EXPORT_C TInt RMMFAudioPolicyProxy::GetRecordFormatsSupported(RMdaDevSound::TSoundFormatsSupportedBuf& aRecordFormatsSupported) 
	{
	RMdaDevSound::TSoundFormatsSupportedBuf recordFormatsSupported;
	TInt err = SendReceiveResult(EMMFPolicyGetRecordFormatsSupported, recordFormatsSupported);
	if (!err)
		aRecordFormatsSupported = recordFormatsSupported;
	return  err;
	}

EXPORT_C TInt RMMFAudioPolicyProxy::GetPlayFormat(RMdaDevSound::TCurrentSoundFormatBuf& aPlayFormat) 
	{
	RMdaDevSound::TCurrentSoundFormatBuf playFormat;
	TInt err = SendReceiveResult(EMMFPolicyGetPlayFormat, playFormat);
	if (!err)
		aPlayFormat = playFormat;
	return  err;
	}

EXPORT_C TInt RMMFAudioPolicyProxy::GetRecordFormat(RMdaDevSound::TCurrentSoundFormatBuf& aRecordFormat) 
	{
	RMdaDevSound::TCurrentSoundFormatBuf recordFormat;
	TInt err = SendReceiveResult(EMMFPolicyGetRecordFormat, recordFormat);
	if (!err)
		aRecordFormat = recordFormat;
	return  err;
	}

EXPORT_C TInt RMMFAudioPolicyProxy::LaunchRequests()
	{
	return SendReceive(EMMFPolicyLaunchRequests);
	}

EXPORT_C TInt RMMFAudioPolicyProxy::RequestResourceNotification(TUid aNotificationEventUid, const TDesC8& aNotificationDelay)
	{
	TUid eventType = KNullUid;
	TMMFAudioPolicyResourceNotificationSettingsPckg pckg;
	pckg().iNotificationUid = eventType;
	TInt err = SendReceiveResult(EMMFPolicyGetResourceNotificationEvent, pckg);
	eventType = pckg().iNotificationUid;
	if(!err)
		{
		if(eventType != aNotificationEventUid )
			{
			pckg().iNotificationUid = aNotificationEventUid;
			pckg().iNotificationDelay = aNotificationDelay;
			return SendReceive(EMMFPolicyRequestResourceNotification, pckg);		
			}
		else
			{
			return KErrAlreadyExists;
			}
		}
	return err;	
	}
	
EXPORT_C TInt RMMFAudioPolicyProxy::CancelRequestResourceNotification(TUid aNotificationEventUid)
	{
	TUid eventType = KNullUid;
	TMMFAudioPolicyResourceNotificationSettingsPckg pckg;
	pckg().iNotificationUid = eventType;
	TInt err = SendReceiveResult(EMMFPolicyGetResourceNotificationEvent, pckg);
	eventType = pckg().iNotificationUid;
	if(!err)
		{
		if(eventType == aNotificationEventUid )
			{
			pckg().iNotificationUid = aNotificationEventUid;
			return SendReceive(EMMFPolicyCancelRequestResourceNotification, pckg);	
			}
		else
			{
			return KErrCancel;
			}
		}
	return err;
	}
	
EXPORT_C TInt RMMFAudioPolicyProxy::StopNotification()
	{
	return SendReceive(EMMFPolicyStopNotification);
	}

EXPORT_C TInt RMMFAudioPolicyProxy::IsRegisteredResourceNotification(TUid aEventType)
	{
	TUid eventType = KNullUid;
	TMMFAudioPolicyResourceNotificationSettingsPckg pckg;
	pckg().iNotificationUid = eventType;
	TInt err = SendReceiveResult(EMMFPolicyGetResourceNotificationEvent, pckg);
	if(err != KErrNone)
		{
		return err;
		}
	eventType = pckg().iNotificationUid;
	if(eventType == aEventType)
		{
		return KErrNone;
		}
	return KErrNotSupported;
	}