diff -r 000000000000 -r bde4ae8d615e os/mm/devsound/sounddevbt/PlatSec/src/SoundDevice/BtSoundDeviceBody.inl --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/mm/devsound/sounddevbt/PlatSec/src/SoundDevice/BtSoundDeviceBody.inl Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,528 @@ +// Copyright (c) 2001-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: +// SoundDeviceBody.inl +// Initializes DevSound object for the mode aMode for processing audio data +// with hardware device aHWDev. +// On completion of Initialization, the observer will be notified via call back +// InitializeComplete(). +// Leaves on failure. +// @param "MDevSoundObserver& aDevSoundObserver" +// A reference to DevSound Observer instance. +// @param "TUid aHWDev" +// CMMFHwDevice implementation identifier. +// @param "TMMFState aMode" +// Mode for which this object will be used. +// +// + +inline void CMMFDevSoundClientImp::InitializeL(MDevSoundObserver& aDevSoundObserver, TUid aHWDev, TMMFState aMode) + { + TInt initError = KErrNone; + iDevSoundObserver = &aDevSoundObserver; + + // Need to set up an init complete event and message handler + // prior to calling InitializeL() + if (iICHandler) + { + iICHandler->CancelReceiveEvents(); + } + else + { + iICHandler = CMMFInitializeCompleteHandler::NewL(iDevSoundProxy, *iDevSoundObserver); + } + iICHandler->ReceiveEvents(); + + initError = iDevSoundProxy->InitializeL(aHWDev, aMode); + + if (initError) + { + iDevSoundObserver->InitializeComplete(initError); + User::Leave(initError); + } + + if(iBTBFHandler) + { + iBTBFHandler->CancelReceiveEvents(); + } + else + { + iBTBFHandler = CMMFBufferToBeFilledHandler::NewL(iDevSoundProxy, *iDevSoundObserver); + } + iBTBFHandler->ReceiveEvents(); + + + if(iPEHandler) + { + iPEHandler->CancelReceiveEvents(); + } + else + { + iPEHandler = CMMFPlayErrorHandler::NewL(iDevSoundProxy, *iDevSoundObserver); + } + iPEHandler->ReceiveEvents(); + + + if(iREHandler) + { + iREHandler->CancelReceiveEvents(); + } + else + { + iREHandler = CMMFRecordErrorHandler::NewL(iDevSoundProxy, *iDevSoundObserver); + } + iREHandler->ReceiveEvents(); + + + if(iTFHandler) + { + iTFHandler->CancelReceiveEvents(); + } + else + { + iTFHandler = CMMFToneFinishedHandler::NewL(iDevSoundProxy, *iDevSoundObserver); + } + iTFHandler->ReceiveEvents(); + + + if(iBTBEHandler) + { + iBTBEHandler->CancelReceiveEvents(); + } + else + { + iBTBEHandler = CMMFBufferToBeEmptiedHandler::NewL(iDevSoundProxy, *iDevSoundObserver); + } + iBTBEHandler->ReceiveEvents(); + + + if(iSETCHandler) + { + iSETCHandler->CancelReceiveEvents(); + } + else + { + iSETCHandler = CMMFSendEventToClientHandler::NewL(iDevSoundProxy, *iDevSoundObserver); + } + iSETCHandler->ReceiveEvents(); + } + + + +/* + * + * Initializes DevSound object for the mode aMode for processing audio data + * using an array of Hardware devices identified by aHWDevArray identifier + * array. The hardware devices are chained together with data flow starting + * with first array element. + * + * On completion of Initialization, the observer will be notified via call back + * InitializeComplete(). + * + * Leaves on failure. + * + * @param "MDevSoundObserver& aDevSoundObserver" + * A reference to DevSound Observer instance. + * + * @param "CArrayPtr aHWDevArray" + * Array of CMMFHwDevice implementation identifiers. + * + * @param "TMMFState aMode" + * Mode for which this object will be used. + * + */ +inline void CMMFDevSoundClientImp::InitializeL(MDevSoundObserver& /*aDevSoundObserver*/, + CArrayPtr /*aHWDevArray*/, TMMFState /*aMode*/) + { + User::Leave(KErrNotSupported); + } + +/* + * + * Initializes DevSound object for the mode aMode for processing audio data + * with hardware device supporting FourCC aDesiredFourCC. + * + * On completion of Initialization, the observer will be notified via call back + * InitializeComplete(). + * + * Leaves on failure. + * + * @param "MDevSoundObserver& aDevSoundObserver" + * A reference to DevSound Observer instance. + * + * @param "TFourCC aDesiredFourCC" + * CMMFHwDevice implementation FourCC. + * + * @param "TMMFState aMode" + * Mode for which this object will be used. + * + */ +inline void CMMFDevSoundClientImp::InitializeL(MDevSoundObserver& aDevSoundObserver, + TFourCC aDesiredFourCC, TMMFState aMode) + { + TInt initError = KErrNone; + iDevSoundObserver = &aDevSoundObserver; + + // Need to set up an init complete event and message handler + // prior to calling InitializeL() + if (iICHandler) + { + iICHandler->CancelReceiveEvents(); + } + else + { + iICHandler = CMMFInitializeCompleteHandler::NewL(iDevSoundProxy, *iDevSoundObserver); + } + iICHandler->ReceiveEvents(); + + initError = iDevSoundProxy->InitializeL(aDesiredFourCC, aMode); + + if (initError) + { + iDevSoundObserver->InitializeComplete(initError); + User::Leave(initError); + } + + if(iBTBFHandler) + { + iBTBFHandler->CancelReceiveEvents(); + } + else + { + iBTBFHandler = CMMFBufferToBeFilledHandler::NewL(iDevSoundProxy, *iDevSoundObserver); + } + iBTBFHandler->ReceiveEvents(); + + + if(iPEHandler) + { + iPEHandler->CancelReceiveEvents(); + } + else + { + iPEHandler = CMMFPlayErrorHandler::NewL(iDevSoundProxy, *iDevSoundObserver); + } + iPEHandler->ReceiveEvents(); + + + if(iREHandler) + { + iREHandler->CancelReceiveEvents(); + } + else + { + iREHandler = CMMFRecordErrorHandler::NewL(iDevSoundProxy, *iDevSoundObserver); + } + iREHandler->ReceiveEvents(); + + + if(iTFHandler) + { + iTFHandler->CancelReceiveEvents(); + } + else + { + iTFHandler = CMMFToneFinishedHandler::NewL(iDevSoundProxy, *iDevSoundObserver); + } + iTFHandler->ReceiveEvents(); + + + if(iBTBEHandler) + { + iBTBEHandler->CancelReceiveEvents(); + } + else + { + iBTBEHandler = CMMFBufferToBeEmptiedHandler::NewL(iDevSoundProxy, *iDevSoundObserver); + } + iBTBEHandler->ReceiveEvents(); + + + if(iSETCHandler) + { + iSETCHandler->CancelReceiveEvents(); + } + else + { + iSETCHandler = CMMFSendEventToClientHandler::NewL(iDevSoundProxy, *iDevSoundObserver); + } + iSETCHandler->ReceiveEvents(); + + } + +/* + * + * Returns the supported Audio settings. + * + * @return "TMMFCapabilities" + * Device settings. + * + */ +inline TMMFCapabilities CMMFDevSoundClientImp::Capabilities() + { + return iDevSoundProxy->Capabilities(); + } + +/* + * + * Returns the current audio settings. + * + * @return "TMMFCapabilities" + * Device settings. + * + */ +inline TMMFCapabilities CMMFDevSoundClientImp::Config() const + { + return iDevSoundProxy->Config(); + } + +/* + * + * Returns an integer representing the maximum volume. + * + * This is the maximum value which can be passed to CMMFDevSound::SetVolume. + * + * @return "TInt" + * The maximum volume. This value is platform dependent but is always + * greater than or equal to one. + * + */ +inline TInt CMMFDevSoundClientImp::MaxVolume() + { + return iDevSoundProxy->MaxVolume(); + } + +/* + * + * Returns an integer representing the current volume. + * + * @return "TInt" + * The current volume level. + * + */ +inline TInt CMMFDevSoundClientImp::Volume() + { + return iDevSoundProxy->Volume(); + } + +/* + * + * Returns an integer representing the maximum gain. + * + * This is the maximum value which can be passed to CMMFDevSound::SetGain. + * + * @return "TInt" + * The maximum gain. This value is platform dependent but is always + * greater than or equal to one. + * + */ +inline TInt CMMFDevSoundClientImp::MaxGain() + { + return iDevSoundProxy->MaxGain(); + } + +/* + * + * Returns an integer representing the current gain. + * + * @return "TInt" + * The current gain level. + * + */ +inline TInt CMMFDevSoundClientImp::Gain() + { + return iDevSoundProxy->Gain(); + } + +/* + * + * Returns the speaker balance set for playing. + * + * Leaves on failure. + * + * @param "TInt& aLeftPercentage" + * On return contains the left speaker volume percentage. + * + * @param "TInt& aRightPercentage" + * On return contains the right speaker volume percentage. + * + */ +inline void CMMFDevSoundClientImp::GetPlayBalanceL(TInt& aLeftPercentage, TInt& aRightPercentage) + { + iDevSoundProxy->GetPlayBalanceL(aLeftPercentage, aRightPercentage); + } + +/* + * + * Returns the microphone gain balance set for recording. + * + * Leaves on failure. + * + * @param "TInt& aLeftPercentage" + * On return contains the left microphone gain percentage. + * + * @param "TInt& aRightPercentage" + * On return contains the right microphone gain percentage. + * + */ +inline void CMMFDevSoundClientImp::GetRecordBalanceL(TInt& aLeftPercentage, TInt& aRightPercentage) + { + iDevSoundProxy->GetRecordBalanceL(aLeftPercentage, aRightPercentage); + } + +/* + * + * Contine the process of recording. Once the buffer is filled with recorded + * data, the Observer gets reference to buffer along with callback + * BufferToBeEmptied(). After processing the buffer (copying over to a + * different buffer or writing to file) the client should call this + * method to continue recording process. + * + */ +inline void CMMFDevSoundClientImp::RecordData() + { + ASSERT(iDevSoundObserver); + iDevSoundProxy->RecordData(); + } + +/* + * + * Defines the number of times the audio is to be repeated during the tone + * playback operation. + * + * A period of silence can follow each playing of tone. The tone playing can + * be repeated indefinitely. + * + * @param "TInt aRepeatCount" + * The number of times the tone, together with the trailing silence, + * is to be repeated. If this is set to KMdaRepeatForever, then the + * tone, together with the trailing silence, is repeated indefinitely + * or until Stop() is called. If this is set to zero, then the tone is + * not repeated. + * + * Supported only during tone playing. + * + */ +inline void CMMFDevSoundClientImp::SetToneRepeats(TInt aRepeatCount, + const TTimeIntervalMicroSeconds& aRepeatTrailingSilence) + { + iDevSoundProxy->SetToneRepeats(aRepeatCount, aRepeatTrailingSilence); + } + +/* + * + * Defines the priority settings that should be used for this instance. + * + * @param "const TMMFPrioritySettings& aPrioritySettings" + * An class type representing the client's priority, priority + * preference and state. + * + */ +inline void CMMFDevSoundClientImp::SetPrioritySettings(const TMMFPrioritySettings& aPrioritySettings) + { + iDevSoundProxy->SetPrioritySettings(aPrioritySettings); + } + +/* + * + * Initializes and starts conversion process. Once the process is initiated, + * observer's call back method BufferToBeFilled() is called with reference to + * the buffer into which source format data is to be read. + * + * The maximum size of data (in bytes) that can be converted is specified in + * CMMFBuffer::RequestSize(). Any data that is read into buffer beyond this + * size will be ignored. + * + * Leaves on failure. + * @prototype + */ +inline void CMMFDevSoundClientImp::ConvertInitL() + { + iDevSoundProxy->ConvertInitL(); + } + +/* + * + * Converts the data in the buffer from source format to destination format. + * After the data is converted to destination format, a reference to the buffer + * containing data in destination format is passed in the observer call back + * method BufferToBeEmptied(). + * + * The amount of data contained in buffer is specified in + * CMMFBuffer::RequestSize(). + * @prototype + */ +inline void CMMFDevSoundClientImp::ConvertData() + { + iDevSoundProxy->ConvertData(); + } + +// No custom interfaces are supported sp return NULL. +inline TAny* CMMFDevSoundClientImp::CustomInterface(TUid aInterfaceId) + { + if(aInterfaceId == KMmfUidDevSoundAudioResourceCustomInterface) + { + MAutoPauseResumeSupport* result = this; + return result; + } + if(aInterfaceId == KMmfUidDevSoundAudioClientThreadInfoCustomInterface) + { + MAudioClientThreadInfo* result = this; + return result; + } + return iDevSoundProxy->CustomInterface(aInterfaceId); + } + +/* + * + * Returns the number of available pre-defined tone sequences. + * + * This is the number of fixed sequence supported by DevSound by default. + * + * @return "TInt" + * The fixed sequence count. This value is implementation dependent + * but is always greater than or equal to zero. + * + */ +inline TInt CMMFDevSoundClientImp::FixedSequenceCount() + { + + return iDevSoundProxy->FixedSequenceCount(); + } + +/* + * + * Returns the name assigned to a specific pre-defined tone sequence. + * + * This is the number of fixed sequence supported by DevSound by default. + * + * The function raises a panic if sequence number specified invalid. + * + * @return "TDesC&" + * A reference to a Descriptor containing the fixed sequence + * name indexed by aSequenceNumber. + * + * @param "TInt aSequenceNumber" + * The index identifying the specific pre-defined tone sequence. Index + * values are relative to zero. + * This can be any value from zero to the value returned by a call to + * CMdaAudioPlayerUtility::FixedSequenceCount() - 1. + * The function raises a panic if sequence number is not within this + * range. + * + */ +inline const TDesC& CMMFDevSoundClientImp::FixedSequenceName(TInt aSequenceNumber) + { + return iDevSoundProxy->FixedSequenceName(aSequenceNumber); + } +