diff -r 94fc26b6e006 -r 1fa3fb47b1e3 mmserv/radioutility/radioserver/Session/stub/src/StubRadioSession.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmserv/radioutility/radioserver/Session/stub/src/StubRadioSession.cpp Wed Aug 18 10:17:22 2010 +0300 @@ -0,0 +1,1773 @@ +/* +* Copyright (c) 2002-2004 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 class is the main interface to the RadioServer. It implements +* the client-side session. +* +*/ + + + +// INCLUDE FILES +#include +#include "StubRadioSession.h" +#include "RadioClientServer.h" +#include "RadioRequest.h" +#include "RadioEventHandler.h" +#include "RadioDebug.h" +#include "trace.h" + +// CONSTANTS +// Index to list of asynchronous requests that generates response to MRadioObserver. +const TInt KReqInternal = 0; +const TInt KReqRequestTunerControl = 1; +const TInt KReqSetFrequencyRange = 2; +const TInt KReqSetFrequency = 3; +const TInt KReqStationSeek = 4; +const TInt KReqPlay = 5; +const TInt KReqStationSeekByPTY = 6; +const TInt KReqStationSeekByTA = 7; +const TInt KReqStationSeekByTP = 8; + +// Max number of retries to start the server +const TInt KRadioStartRetry = 2; +// Minimum of one for each asynchronous message + one to allow cancel +const TInt KRadioMessageSlots = 11; + +#define TUNER iRadioStubManager->iTuner +#define PLAYER iRadioStubManager->iPlayer +#define RDS iRadioStubManager->iRds + + +// ============================= LOCAL FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// StartServer +// Static function to start the server process thread. +// Start the server process/thread which lives in an EPOCEXE object. +// Returns: TInt: KErrNone (0) if no error +// ----------------------------------------------------------------------------- +// +static TInt StartServer() + { + FUNC_LOG; + + const TUidType serverUid(KNullUid, KNullUid, KRadioServerUid3); + + // We just create a new server process. Simultaneous launching of two such + // processes should be detected when the second one attempts to create + // the server object, failing with KErrAlreadyExists. + RProcess server; + TInt r = server.Create(KRadioServerImg, KNullDesC, serverUid); + + if ( r != KErrNone ) + { + INFO_1("server.Create() failed [%d]", r); + return r; + } + TRequestStatus stat; + server.Rendezvous(stat); + if ( stat != KRequestPending ) + { + server.Kill(0); // abort startup + } + else + { + server.Resume(); // logon OK - start the server + } + User::WaitForRequest(stat); // wait for start or death + // we can't use the 'exit reason' if the server panicked as this + // is the panic 'reason' and may be '0' which cannot be distinguished + // from KErrNone + r = (server.ExitType() == EExitPanic) ? KErrGeneral : stat.Int(); + server.Close(); + return r; + } + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// RRadioSession::NewL +// Two-phased constructor except no need for ConstrucL +// ----------------------------------------------------------------------------- +// +EXPORT_C RRadioSession* RRadioSession::NewL() + { + FUNC_LOG; + RRadioSession* self = new (ELeave) RRadioSession(); + return self; + } + +// ----------------------------------------------------------------------------- +// RRadioSession::RRadioSession +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +EXPORT_C RRadioSession::RRadioSession() + : iConnected(EFalse), + iDestinationPckg(TMMFMessageDestination(KRadioServerInterfaceUid, KRadioServerObjectHandle)), + iObserver(NULL), + iPrimaryClient(EFalse), + iRdsNotify(EFalse) + { + FUNC_LOG; + } + +// ----------------------------------------------------------------------------- +// RRadioSession::Connect +// Create a client-side session. Start the server if not started already. +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RRadioSession::Connect( + MRadioObserver& aObserver, + TBool aPrimaryClient ) + { + FUNC_LOG; + INFO_1("Size of RRadioSession: %i", sizeof(RRadioSession) ); + // check if already connected + if ( iConnected ) + { + INFO("already connected"); + return KErrAlreadyExists; + } + + TInt retry = KRadioStartRetry; + TInt err = KErrGeneral; + TInt numMessageSlots = KRadioMessageSlots; + for (;;) + { + // Try to create a new session with the server + err = CreateSession(KRadioServerName, Version(), numMessageSlots); + if ( (err != KErrNotFound) && (err != KErrServerTerminated) ) + { + break; // Connected to existing server - ok + } + if ( --retry == 0 ) + { + break; // Failed. + } + // Server not running, try to start it. + err = StartServer(); + if ( (err != KErrNone) && (err != KErrAlreadyExists) ) + { + break; // Server not launched - propagate error + } + } + + if ( err != KErrNone ) + { + INFO_1("Unable to start server [%d]", err); + return err; + } + // Dooing some temporary manipulation for heap + User::Check(); + User::CompressAllHeaps(); + CRadioRequest* req( NULL ); + TRAP(err, req = CRadioRequest::NewLC(*this, aObserver, ERadioServNone); CleanupStack::Pop( req ) ); + iExtraRequestForBugHunting = req; + User::Check(); + User::CompressAllHeaps(); + //delete iExtraRequestForBugHunting; + //iExtraRequestForBugHunting = NULL; + + // Create active object request handlers and add it to scheduler + TRAP(err, StartRequestHandlersL(aObserver)); + if ( err == KErrNone ) + { + // Create active object event handlers and add it to scheduler + TRAP(err, StartEventHandlersL(aObserver)); + if ( err == KErrNone ) + { + iConnected = ETrue; + iObserver = &aObserver; + if ( aPrimaryClient ) + { + iPrimaryClient = ETrue; + err = SendReceive(ERadioServAddPrimaryClient, TIpcArgs(&iDestinationPckg)); + } + } + else + { + iRequests.ResetAndDestroy(); + iEventHandlers.ResetAndDestroy(); + } + } + else + { + iRequests.ResetAndDestroy(); + } + // Open chunk for test configuration/control data + // Open chunk for test configuration/control data + User::Check(); + User::CompressAllHeaps(); + err = iRadioStubManagerChunk.OpenGlobal( + KRadioStubManagerLocalChunkName, + EFalse, // == Read | Write + EOwnerThread ); + if (err) + { + goto exitAndReturn; + } + User::Check(); + User::CompressAllHeaps(); + if ( sizeof(SRadioStubManager) > iRadioStubManagerChunk.MaxSize() ) + { + err = KErrTooBig; + goto exitAndReturn; + } + TUint8* basePtr = iRadioStubManagerChunk.Base(); + User::LeaveIfNull( basePtr ); + if (!basePtr) + { + err = KErrGeneral; + goto exitAndReturn; + } + User::Check(); + User::CompressAllHeaps(); + iRadioStubManager = (SRadioStubManager*)basePtr; + +exitAndReturn: + User::Check(); + User::CompressAllHeaps(); + INFO_1("exit err=[%d]", err); + return err; + } + +// ----------------------------------------------------------------------------- +// RRadioSession::Version +// ----------------------------------------------------------------------------- +// +EXPORT_C TVersion RRadioSession::Version() const + { + return(TVersion(KRadioServerVersionMajor, KRadioServerVersionMinor, KRadioServerVersionBuild)); + } + +// ----------------------------------------------------------------------------- +// RRadioSession::Close +// ----------------------------------------------------------------------------- +// +EXPORT_C void RRadioSession::Close() + { + FUNC_LOG; + + //delete iExtraRequestForBugHunting; + iEventHandlers.ResetAndDestroy(); + iEventHandlers.Close(); + + iRdsEventHandlers.ResetAndDestroy(); + iRdsEventHandlers.Close(); + + for ( TInt i = (iRequests.Count() - 1) ; i >= 0; i = (iRequests.Count()- 1) ) + { + INFO_2("iRequests[i] pointer: 0x%x, no: %i", *&iRequests[i], i ); + CRadioRequest* req = *&iRequests[i]; + iRequests.Remove(i); + delete req; + } + //iRequests.ResetAndDestroy(); + iRequests.Close(); + + if ( iConnected ) + { + iConnected = EFalse; + if ( iPrimaryClient ) + { + SendReceive(ERadioServRemovePrimaryClient, TIpcArgs(&iDestinationPckg)); + } + RSessionBase::Close(); + } + // Dooing some temporary manipulation for heap + //User::Check(); + //User::CompressAllHeaps(); + delete iExtraRequestForBugHunting; + } + +//********** TunerUtility control begins + +// ----------------------------------------------------------------------------- +// RRadioSession::RequestTunerControl +// ----------------------------------------------------------------------------- +// +EXPORT_C void RRadioSession::RequestTunerControl( + TRsTuner /*aTuner*/ ) + { + FUNC_LOG; + if ( iConnected ) + { + if ( !iRequests[KReqRequestTunerControl]->IsActive() ) + { + iRequests[KReqRequestTunerControl]->CompleteRequest(ERadioServRequestTunerControl, KErrNone); + } + } + else + { + iRequests[KReqInternal]->CompleteRequest(ERadioServRequestTunerControl, KErrDisconnected); + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetTunerCapabilities +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RRadioSession::GetTunerCapabilities( + TRsTunerCapabilities& aCaps ) const + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( TUNER.iGetCapabilitiesError.Error() ); + if ( KErrNone == err ) + { + aCaps.iFrequencyRange = TUNER.iCaps.iFrequencyRange; + aCaps.iCapabilities = TUNER.iCaps.iCapabilities; + aCaps.iAdditionalFunctions1 = TUNER.iCaps.iAdditionalFunctions1; + aCaps.iAdditionalFunctions2 = TUNER.iCaps.iAdditionalFunctions2; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::EnableTunerInOfflineMode +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RRadioSession::EnableTunerInOfflineMode( + TBool aEnable ) + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( TUNER.iEnableTunerInOfflineModeError.Error() ); + if ( KErrNone == err ) + { + TUNER.iTunerInOfflineMode = aEnable; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::SetFrequencyRange +// ----------------------------------------------------------------------------- +// +EXPORT_C void RRadioSession::SetFrequencyRange( + TRsFrequencyRange aRange ) + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( TUNER.iSetFrequencyRangeError.Error() ); + if ( KErrNone == err ) + { + TUNER.iPreviousRange = TUNER.iRange; + TUNER.iRange = aRange; + } + if ( iRequests[KReqSetFrequencyRange]->IsActive() ) + { + iRequests[KReqSetFrequencyRange]->Cancel(); + } + iRequests[KReqSetFrequencyRange]->CompleteRequest(ERadioServSetFrequencyRange, err); + } + else + { + iRequests[KReqInternal]->CompleteRequest(ERadioServSetFrequencyRange, KErrDisconnected); + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::CancelSetFrequencyRange +// ----------------------------------------------------------------------------- +// +EXPORT_C void RRadioSession::CancelSetFrequencyRange() + { + FUNC_LOG; + if ( iConnected && iRequests[KReqSetFrequencyRange]->IsActive() ) + { + iRequests[KReqSetFrequencyRange]->Cancel(); + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetFrequencyRange +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RRadioSession::GetFrequencyRange( + TRsFrequencyRange& aRange, + TInt& aMinFreq, + TInt& aMaxFreq) const + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( TUNER.iGetFrequencyRangeError.Error() ); + if ( KErrNone == err ) + { + aRange = TUNER.iRange; + aMinFreq = TUNER.iMinFreq; + aMaxFreq = TUNER.iMaxFreq; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::SetFrequency +// ----------------------------------------------------------------------------- +// +EXPORT_C void RRadioSession::SetFrequency( + TInt aFrequency ) + { + FUNC_LOG; + if ( iConnected ) + { + TUint err( TUNER.iSetFrequencyError.Error() ); + if ( KErrNone == err ) + { + TUNER.iPreviousFrequency = TUNER.iFrequency; + TUNER.iFrequency = aFrequency; + } + if ( iRequests[KReqSetFrequency]->IsActive() ) + { + iRequests[KReqSetFrequency]->Cancel(); + } + iRequests[KReqSetFrequency]->CompleteRequest(ERadioServSetFrequency, err); + } + else + { + iRequests[KReqInternal]->CompleteRequest(ERadioServSetFrequency, KErrDisconnected); + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::CancelSetFrequency +// ----------------------------------------------------------------------------- +// +EXPORT_C void RRadioSession::CancelSetFrequency() + { + FUNC_LOG; + if ( iConnected && iRequests[KReqSetFrequency]->IsActive() ) + { + iRequests[KReqSetFrequency]->Cancel(); + } + TUNER.iFrequency = TUNER.iPreviousFrequency; + TUNER.iPreviousFrequency = 0; + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetFrequency +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RRadioSession::GetFrequency( + TInt& aFrequency ) const + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( TUNER.iGetFrequencyError.Error() ); + if ( KErrNone == err ) + { + aFrequency = TUNER.iFrequency; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::StationSeek +// ----------------------------------------------------------------------------- +EXPORT_C void RRadioSession::StationSeek( + TBool aUpwards ) + { + FUNC_LOG; + INFO_1("aUpwards: %D", aUpwards ); + if ( iConnected ) + { + TUNER.iStationSeekUpwards = aUpwards; + if ( iRequests[KReqStationSeek]->IsActive() ) + { + iRequests[KReqStationSeek]->Cancel(); + } + TInt err( KErrNone); + if ( KErrNotFound == TUNER.iScanStations.iCount ) + { + err = KErrNotFound; + } + else if ( TUNER.iScanStations.iCount ) + { + iRequests[KReqStationSeek]->iInt = TUNER.iScanStations.iMinFreq + ( TUNER.iScanStations.iCount * TUNER.iScanStations.iFrequencyStepSize ); + --TUNER.iScanStations.iCount; + if ( 0 == TUNER.iScanStations.iCount ) + { + TUNER.iScanStations.iCount = KErrNotFound; + } + } + else + { + iRequests[KReqStationSeek]->iInt = TUNER.iFrequency; + } + iRequests[KReqStationSeek]->CompleteRequest(ERadioServStationSeek, err); + } + else + { + iRequests[KReqInternal]->CompleteRequest(ERadioServStationSeek, KErrDisconnected); + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::CancelStationSeek +// ----------------------------------------------------------------------------- +EXPORT_C void RRadioSession::CancelStationSeek() + { + FUNC_LOG; + if ( iConnected && iRequests[KReqStationSeek]->IsActive() ) + { + iRequests[KReqStationSeek]->Cancel(); + } + TUNER.iScanStations.iCount = 0; + TUNER.iStationSeekUpwards = EFalse; + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetSignalStrength +// ----------------------------------------------------------------------------- +EXPORT_C TInt RRadioSession::GetSignalStrength( + TInt& aSignalStrength ) const + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( TUNER.iGetSignalStrengthError.Error() ); + if ( KErrNone == err ) + { + aSignalStrength = TUNER.iSignalStrength; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetMaxSignalStrength +// ----------------------------------------------------------------------------- +EXPORT_C TInt RRadioSession::GetMaxSignalStrength( + TInt& aMaxSignalStrength ) const + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( TUNER.iGetMaxSignalStrengthError.Error() ); + if ( KErrNone == err ) + { + aMaxSignalStrength = TUNER.iMaxSignalStrength; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetStereoMode +// ----------------------------------------------------------------------------- +EXPORT_C TInt RRadioSession::GetStereoMode( + TBool& aStereo ) const + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( TUNER.iGetStereoModeError.Error() ); + if ( KErrNone == err ) + { + aStereo = TUNER.iStereoMode; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::ForceMonoReception +// ----------------------------------------------------------------------------- +EXPORT_C TInt RRadioSession::ForceMonoReception( + TBool aForcedMono ) + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( TUNER.iForcedMonoReceptionError.Error() ); + if ( KErrNone == err ) + { + TUNER.iForcedMono = aForcedMono; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetForceMonoReception +// ----------------------------------------------------------------------------- +EXPORT_C TInt RRadioSession::GetForceMonoReception( + TBool& aForcedMono ) const + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( TUNER.iGetForcedMonoReceptionError.Error() ); + if ( KErrNone == err ) + { + aForcedMono = TUNER.iForcedMono; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::SetSquelch +// ----------------------------------------------------------------------------- +EXPORT_C TInt RRadioSession::SetSquelch( + TBool aEnabled ) + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( TUNER.iSetSquelchError.Error() ); + if ( KErrNone == err ) + { + TUNER.iSquelch = aEnabled; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetSquelch +// ----------------------------------------------------------------------------- +EXPORT_C TInt RRadioSession::GetSquelch( + TBool& aSquelch ) const + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( TUNER.iGetSquelchError.Error() ); + if ( KErrNone == err ) + { + aSquelch = TUNER.iSquelch; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +//********** PlayerUtility control begins + +// ----------------------------------------------------------------------------- +// RRadioSession::PlayerState +// ----------------------------------------------------------------------------- +EXPORT_C TInt RRadioSession::PlayerState( + TRsPlayerState& aState ) const + { + FUNC_LOG; + if ( iConnected ) + { + aState = PLAYER.iPlayerState; + return KErrNone; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::Play +// ----------------------------------------------------------------------------- +EXPORT_C void RRadioSession::Play() + { + FUNC_LOG; + if ( iConnected ) + { + PLAYER.iPlayerState = ERsPlayerPlaying; + if ( iRequests[KReqPlay]->IsActive() ) + { + iRequests[KReqStationSeek]->Cancel(); + } + iRequests[KReqPlay]->CompleteRequest(ERadioServPlay, KErrNone); + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::Stop +// ----------------------------------------------------------------------------- +EXPORT_C void RRadioSession::Stop( + TBool aIfOnlyPrimaryClient ) + { + FUNC_LOG; + INFO_1("aIfOnlyPrimaryClient: [%d]", aIfOnlyPrimaryClient); + if ( iConnected & aIfOnlyPrimaryClient ) + { + PLAYER.iPlayerState = ERsPlayerIdle; + RProperty::Set( KRadioServerPropertyCategory, ERadioServPsPlayerState, PLAYER.iPlayerState ); + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetMaxVolume +// ----------------------------------------------------------------------------- +EXPORT_C TInt RRadioSession::GetMaxVolume( + TInt& aMaxVolume ) const + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( PLAYER.iGetMaxVolumeError.Error() ); + if ( KErrNone == err ) + { + aMaxVolume = PLAYER.iMaxVolume; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::SetVolume +// ----------------------------------------------------------------------------- +EXPORT_C TInt RRadioSession::SetVolume( + TInt aVolume ) + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( PLAYER.iSetVolumeError.Error() ); + if ( KErrNone == err ) + { + PLAYER.iVolume = aVolume; + RProperty::Set( KRadioServerPropertyCategory, ERadioServPsVolume, PLAYER.iVolume ); + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetVolume +// ----------------------------------------------------------------------------- +EXPORT_C TInt RRadioSession::GetVolume( + TInt& aVolume ) const + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( PLAYER.iGetVolumeError.Error() ); + if ( KErrNone == err ) + { + aVolume = PLAYER.iVolume; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::SetVolumeRamp +// ----------------------------------------------------------------------------- +EXPORT_C TInt RRadioSession::SetVolumeRamp( + const TTimeIntervalMicroSeconds& aRampInterval ) + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( PLAYER.iSetVolumeRampError.Error() ); + if ( KErrNone == err ) + { + PLAYER.iRampInterval = aRampInterval; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::Mute +// ----------------------------------------------------------------------------- +EXPORT_C TInt RRadioSession::Mute( + TBool aMute ) + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( PLAYER.iMuteError.Error() ); + if ( KErrNone == err ) + { + PLAYER.iMuteStatus = aMute; + RProperty::Set( KRadioServerPropertyCategory, ERadioServPsMuteStatus, PLAYER.iMuteStatus ); + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetMuteStatus +// ----------------------------------------------------------------------------- +EXPORT_C TInt RRadioSession::GetMuteStatus( + TBool& aMute ) const + { + FUNC_LOG; + if ( iConnected ) + { + aMute = PLAYER.iMuteStatus; + return KErrNone; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::SetBalance +// ----------------------------------------------------------------------------- +EXPORT_C TInt RRadioSession::SetBalance( + TInt aLeftPercentage, + TInt aRightPercentage ) + { + FUNC_LOG; + INFO_2("left=[%d] right=[%d]", aLeftPercentage, aRightPercentage); + if ( iConnected ) + { + TInt err( PLAYER.iSetBalanceError.Error() ); + if ( KErrNone == err ) + { + PLAYER.iLeftPercentage = aLeftPercentage; + PLAYER.iRightPercentage = aRightPercentage; + //iRadioPlayerUtilityClient.MrpoBalanceChange( STUB.iLeftPercentage, STUB.iRightPercentage ); + TPckgBuf balance; + balance().iData1 = aLeftPercentage; // Left + balance().iData2 = aRightPercentage; // Right + RProperty::Set( KRadioServerPropertyCategory, ERadioServPsBalance, balance ); + } + return err; + + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetBalance +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RRadioSession::GetBalance( + TInt& aLeftPercentage, + TInt& aRightPercentage ) const + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( PLAYER.iSetBalanceError.Error() ); + if ( KErrNone == err ) + { + aLeftPercentage = PLAYER.iLeftPercentage; + aRightPercentage = PLAYER.iRightPercentage; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +//********** RDSUtility control begins + +// ----------------------------------------------------------------------------- +// RRadioSession::GetRdsCapabilities +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RRadioSession::GetRdsCapabilities( + TRsRdsCapabilities& aCaps ) const + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( RDS.iGetCapabilitiesError.Error() ); + if ( KErrNone == err ) + { + aCaps.iRdsFunctions = RDS.iCaps.iRdsFunctions; + aCaps.iAdditionalFunctions1 = RDS.iCaps.iAdditionalFunctions1; + aCaps.iAdditionalFunctions2 = RDS.iCaps.iAdditionalFunctions2; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetRdsSignalStatus +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RRadioSession::GetRdsSignalStatus( + TBool& aRdsSignal ) const + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( RDS.iGetRdsSignalStatusError.Error() ); + if ( KErrNone == err ) + { + aRdsSignal = RDS.iRdsSignal; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::NotifyRdsDataChange +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RRadioSession::NotifyRdsDataChange( + TRsRdsData aRdsData ) + { + FUNC_LOG; + INFO_1("aRdsData.iRdsFunctions [%d]", aRdsData.iRdsFunctions); + if ( !iConnected ) + { + return KErrDisconnected; + } + + if ( !iObserver ) + { + return KErrNotReady; + } + + TRAPD(err, StartRdsEventHandlersL(aRdsData.iRdsFunctions)); + if ( err != KErrNone ) + { + INFO_1("err=[%d]", err); + return err; + } + iRdsNotify = ETrue; + return err; + } + +// ----------------------------------------------------------------------------- +// RRadioSession::CancelNotifyRdsDataChange +// ----------------------------------------------------------------------------- +// +EXPORT_C void RRadioSession::CancelNotifyRdsDataChange() + { + FUNC_LOG; + if ( iConnected && iRdsNotify ) + { + iRdsEventHandlers.ResetAndDestroy(); + iRdsNotify = EFalse; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::NotifyRadioTextPlusChange +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RRadioSession::NotifyRadioTextPlusChange( + RArray& /*aRtPlusClasses*/ ) + { + FUNC_LOG; + return KErrNotSupported; + } + +// ----------------------------------------------------------------------------- +// RRadioSession::CancelNotifyRadioTextPlusChange +// ----------------------------------------------------------------------------- +// +EXPORT_C void RRadioSession::CancelNotifyRadioTextPlusChange() + { + FUNC_LOG; + // NotifyRadioTextPlusChange is not supported + } + +// ----------------------------------------------------------------------------- +// RRadioSession::SetAutomaticSwitching +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RRadioSession::SetAutomaticSwitching( + TBool aAuto ) + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( RDS.iSetAutomaticSwitchingError.Error() ); + if ( KErrNone == err ) + { + RDS.iAutomaticSwitching = aAuto; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetAutomaticSwitching +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RRadioSession::GetAutomaticSwitching( + TBool& aAuto ) + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( RDS.iGetAutomaticSwitchingError.Error() ); + if ( KErrNone == err ) + { + aAuto = RDS.iAutomaticSwitching; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::CancelAFSearch +// ----------------------------------------------------------------------------- +// +EXPORT_C void RRadioSession::CancelAFSearch() + { + FUNC_LOG; + } + + // ----------------------------------------------------------------------------- +// RRadioSession::SetAutomaticTrafficAnnouncement +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RRadioSession::SetAutomaticTrafficAnnouncement( + TBool /*aAuto*/ ) + { + FUNC_LOG; + return KErrNotSupported; + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetAutomaticTrafficAnnouncement +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RRadioSession::GetAutomaticTrafficAnnouncement( + TBool& /*aAuto*/ ) + { + FUNC_LOG; + return KErrNotSupported; + } + +// ----------------------------------------------------------------------------- +// RRadioSession::StationSeekByPTY +// ----------------------------------------------------------------------------- +// +EXPORT_C void RRadioSession::StationSeekByPTY( + TRsRdsProgrammeType aPty, + TBool aSeekUp ) + { + FUNC_LOG; + INFO_2("pty=[%d], aSeekUp=%d", aPty, aSeekUp); + if ( iConnected ) + { + if ( iRequests[KReqStationSeekByPTY]->IsActive() ) + { + iRequests[KReqStationSeekByPTY]->Cancel(); + } + iRequests[KReqStationSeekByPTY]->iInt = RDS.iFrequency; + iRequests[KReqInternal]->CompleteRequest(ERadioServStationSeekByPTY, KErrNone); + } + else + { + iRequests[KReqInternal]->CompleteRequest(ERadioServStationSeekByPTY, KErrDisconnected); + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::StationSeekByTA +// ----------------------------------------------------------------------------- +// +EXPORT_C void RRadioSession::StationSeekByTA( + TBool /*aSeekUp*/ ) + { + FUNC_LOG; + if ( iConnected ) + { + if ( iRequests[KReqStationSeekByTA]->IsActive() ) + { + iRequests[KReqStationSeekByTA]->Cancel(); + } + iRequests[KReqStationSeekByTA]->iInt = RDS.iFrequency; + iRequests[KReqInternal]->CompleteRequest(ERadioServStationSeekByTA, KErrNone); + } + else + { + iRequests[KReqInternal]->CompleteRequest(ERadioServStationSeekByTA, KErrDisconnected); + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::StationSeekByTP +// ----------------------------------------------------------------------------- +// +EXPORT_C void RRadioSession::StationSeekByTP( + TBool /*aSeekUp*/ ) + { + FUNC_LOG; + if ( iConnected ) + { + if ( iRequests[KReqStationSeekByTP]->IsActive() ) + { + iRequests[KReqStationSeekByTP]->Cancel(); + } + iRequests[KReqStationSeekByTP]->iInt = RDS.iFrequency; + iRequests[KReqInternal]->CompleteRequest(ERadioServStationSeekByTP, KErrNone); + } + else + { + iRequests[KReqInternal]->CompleteRequest(ERadioServStationSeekByTP, KErrDisconnected); + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::CancelRdsStationSeek +// ----------------------------------------------------------------------------- +// +EXPORT_C void RRadioSession::CancelRdsStationSeek() + { + FUNC_LOG; + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetFreqByPTY +// ----------------------------------------------------------------------------- +// +EXPORT_C void RRadioSession::GetFreqByPTY( + TRsRdsProgrammeType /*aPty*/ ) + { + FUNC_LOG; + iRequests[KReqInternal]->CompleteRequest(ERadioServGetFreqByPTY, KErrNotSupported); + } + +// ----------------------------------------------------------------------------- +// RRadioSession::CancelGetFreqByPTY +// ----------------------------------------------------------------------------- +// +EXPORT_C void RRadioSession::CancelGetFreqByPTY() + { + FUNC_LOG; + // GetFreqByPTY is not supported + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetFreqByTA +// ----------------------------------------------------------------------------- +// +EXPORT_C void RRadioSession::GetFreqByTA() + { + FUNC_LOG; + iRequests[KReqInternal]->CompleteRequest(ERadioServGetFreqByTA, KErrNotSupported); + } + +// ----------------------------------------------------------------------------- +// RRadioSession::CancelGetFreqByTA +// ----------------------------------------------------------------------------- +// +EXPORT_C void RRadioSession::CancelGetFreqByTA() + { + FUNC_LOG; + // GetFreqByTA is not supported + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetPSByPTY +// ----------------------------------------------------------------------------- +// +EXPORT_C void RRadioSession::GetPSByPTY( + TRsRdsProgrammeType /*aPty*/ ) + { + FUNC_LOG; + iRequests[KReqInternal]->CompleteRequest(ERadioServGetPSByPTY, KErrNotSupported); + } + +// ----------------------------------------------------------------------------- +// RRadioSession::CancelGetPSByPTY +// ----------------------------------------------------------------------------- +// +EXPORT_C void RRadioSession::CancelGetPSByPTY() + { + FUNC_LOG; + // GetPSByPTY is not supported + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetPSByTA +// ----------------------------------------------------------------------------- +// +EXPORT_C void RRadioSession::GetPSByTA() + { + FUNC_LOG; + iRequests[KReqInternal]->CompleteRequest(ERadioServGetPSByTA, KErrNotSupported); + } + +// ----------------------------------------------------------------------------- +// RRadioSession::CancelGetPSByTA +// ----------------------------------------------------------------------------- +// +EXPORT_C void RRadioSession::CancelGetPSByTA() + { + FUNC_LOG; + // GetPSByTA is not supported + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetProgrammeIdentification +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RRadioSession::GetProgrammeIdentification( + TInt& aPi ) + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( RDS.iGetProgrammeIdentificationError.Error() ); + if ( KErrNone == err ) + { + aPi = RDS.iPi; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetProgrammeType +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RRadioSession::GetProgrammeType( + TRsRdsProgrammeType& aPty ) + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( RDS.iGetProgrammeTypeError.Error() ); + if ( KErrNone == err ) + { + aPty = RDS.iPty; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetProgrammeService +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RRadioSession::GetProgrammeService( + TRsRdsPSName& aPs ) + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( RDS.iGetProgrammeServiceError.Error() ); + if ( KErrNone == err ) + { + aPs = RDS.iPs; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetRadioText +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RRadioSession::GetRadioText( + TRsRdsRadioText& aRt ) + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( RDS.iGetRadioTextError.Error() ); + if ( KErrNone == err ) + { + aRt = RDS.iRt; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetRadioTextPlus +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RRadioSession::GetRadioTextPlus( + TRsRdsRTplusClass /*aRtPlusClass*/, + TRsRdsRadioText& /*aRtPlusData*/ ) + { + FUNC_LOG; + return KErrNotSupported; + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetClockTime +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RRadioSession::GetClockTime( + TDateTime& aCt ) + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( RDS.iGetClockTimeError.Error() ); + if ( KErrNone == err ) + { + aCt = RDS.iCt; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetTrafficAnnouncementStatus +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RRadioSession::GetTrafficAnnouncementStatus( + TBool& aTaStatus ) + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( RDS.iGetTrafficAnnouncementStatusError.Error() ); + if ( KErrNone == err ) + { + aTaStatus = RDS.iTaStatus; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::GetTrafficProgrammeStatus +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RRadioSession::GetTrafficProgrammeStatus( + TBool& aTpStatus ) + { + FUNC_LOG; + if ( iConnected ) + { + TInt err( RDS.iGetTrafficProgrammeStatusError.Error() ); + if ( KErrNone == err ) + { + aTpStatus = RDS.iTpStatus; + } + return err; + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::CustomCommandSync +// ----------------------------------------------------------------------------- +EXPORT_C TInt RRadioSession::CustomCommandSync( + const TMMFMessageDestinationPckg& aDestination, + TInt aFunction, + const TDesC8& aDataTo1, + const TDesC8& aDataTo2 ) + { + FUNC_LOG; + if ( iConnected ) + { + return SendReceive(aFunction, TIpcArgs(&aDestination, &aDataTo1, &aDataTo2)); + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::CustomCommandSync +// ----------------------------------------------------------------------------- +EXPORT_C TInt RRadioSession::CustomCommandSync( + const TMMFMessageDestinationPckg& aDestination, + TInt aFunction, + const TDesC8& aDataTo1, + const TDesC8& aDataTo2, + TDes8& aDataFrom ) + { + FUNC_LOG; + if ( iConnected ) + { + return SendReceive(aFunction, TIpcArgs(&aDestination, &aDataTo1, &aDataTo2, &aDataFrom)); + } + else + { + return KErrDisconnected; + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::CustomCommandAsync +// ----------------------------------------------------------------------------- +EXPORT_C void RRadioSession::CustomCommandAsync( + const TMMFMessageDestinationPckg& aDestination, + TInt aFunction, + const TDesC8& aDataTo1, + const TDesC8& aDataTo2, + TRequestStatus& aStatus ) + { + FUNC_LOG; + if ( iConnected ) + { + SendReceive(aFunction, TIpcArgs(&aDestination, &aDataTo1, &aDataTo2), aStatus); + } + else + { + TRequestStatus* stat = &aStatus; + User::RequestComplete(stat, KErrDisconnected); + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::CustomCommandAsync +// ----------------------------------------------------------------------------- +EXPORT_C void RRadioSession::CustomCommandAsync( + const TMMFMessageDestinationPckg& aDestination, + TInt aFunction, + const TDesC8& aDataTo1, + const TDesC8& aDataTo2, + TDes8& aDataFrom, + TRequestStatus& aStatus ) + { + FUNC_LOG; + if ( iConnected ) + { + SendReceive(aFunction, TIpcArgs(&aDestination, &aDataTo1, &aDataTo2, &aDataFrom), aStatus); + } + else + { + TRequestStatus* stat = &aStatus; + User::RequestComplete(stat, KErrDisconnected); + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::CancelRequest +// ----------------------------------------------------------------------------- +// +void RRadioSession::CancelRequest( + TInt aRequest ) + { + FUNC_LOG; + if ( iConnected ) + { + SendReceive(ERadioServCancel, TIpcArgs(&iDestinationPckg, aRequest)); + } + } + +// ----------------------------------------------------------------------------- +// RRadioSession::StartRequestHandlersL +// Create asynchronous request handlers. +// ** NOTE: The order in which each handler is appended to the iRequests array is critical. +// Access to each request is done with constants declared at the beginning of this file. +// ----------------------------------------------------------------------------- +// +void RRadioSession::StartRequestHandlersL( + MRadioObserver& aObserver ) + { + FUNC_LOG; + + CRadioRequest* req = NULL; + + req = CRadioRequest::NewLC(*this, aObserver, ERadioServNone); + User::LeaveIfError( iRequests.Append(req) ); + CleanupStack::Pop( req ); + INFO_2("CRadioRequest* req: 0x%x, no: %i", req, iRequests.Count() ); + + req = CRadioRequest::NewLC(*this, aObserver, ERadioServRequestTunerControl); + User::LeaveIfError( iRequests.Append(req) ); + CleanupStack::Pop( req ); + INFO_2("CRadioRequest* req: 0x%x, no: %i", req, iRequests.Count() ); + + req = CRadioRequest::NewLC(*this, aObserver, ERadioServSetFrequencyRange); + User::LeaveIfError( iRequests.Append(req) ); + CleanupStack::Pop( req ); + INFO_2("CRadioRequest* req: 0x%x, no: %i", req, iRequests.Count() ); + + req = CRadioRequest::NewLC(*this, aObserver, ERadioServSetFrequency); + User::LeaveIfError( iRequests.Append(req) ); + CleanupStack::Pop( req ); + INFO_2("CRadioRequest* req: 0x%x, no: %i", req, iRequests.Count() ); + + req = CRadioRequest::NewLC(*this, aObserver, ERadioServStationSeek); + User::LeaveIfError( iRequests.Append(req) ); + CleanupStack::Pop( req ); + INFO_2("CRadioRequest* req: 0x%x, no: %i", req, iRequests.Count() ); + + req = CRadioRequest::NewLC(*this, aObserver, ERadioServPlay); + User::LeaveIfError( iRequests.Append(req) ); + CleanupStack::Pop( req ); + INFO_2("CRadioRequest* req: 0x%x, no: %i", req, iRequests.Count() ); + + req = CRadioRequest::NewLC(*this, aObserver, ERadioServStationSeekByPTY); + User::LeaveIfError( iRequests.Append(req) ); + CleanupStack::Pop( req ); + INFO_2("CRadioRequest* req: 0x%x, no: %i", req, iRequests.Count() ); + + req = CRadioRequest::NewLC(*this, aObserver, ERadioServStationSeekByTA); + User::LeaveIfError( iRequests.Append(req) ); + CleanupStack::Pop( req ); + INFO_2("CRadioRequest* req: 0x%x, no: %i", req, iRequests.Count() ); + + req = CRadioRequest::NewLC(*this, aObserver, ERadioServStationSeekByTP); + User::LeaveIfError( iRequests.Append(req) ); + CleanupStack::Pop( req ); + INFO_2("CRadioRequest* req: 0x%x, no: %i", req, iRequests.Count() ); + } + +// ----------------------------------------------------------------------------- +// RRadioSession::StartEventHandlersL +// ----------------------------------------------------------------------------- +// +void RRadioSession::StartEventHandlersL( + MRadioObserver& aEventObserver ) + { + FUNC_LOG; + + CRadioEventHandler* handler = NULL; + + handler = CRadioEventHandler::NewLC(aEventObserver, *this, ERadioServPsPlayerState); + User::LeaveIfError( iEventHandlers.Append(handler) ); + CleanupStack::Pop( handler ); + + handler = CRadioEventHandler::NewLC(aEventObserver, *this, ERadioServPsAntennaStatus); + User::LeaveIfError( iEventHandlers.Append(handler) ); + CleanupStack::Pop( handler ); + + handler = CRadioEventHandler::NewLC(aEventObserver, *this, ERadioServPsOfflineMode ); + User::LeaveIfError( iEventHandlers.Append(handler) ); + CleanupStack::Pop( handler ); + + handler = CRadioEventHandler::NewLC(aEventObserver, *this, ERadioServPsTransmitterStatus ); + User::LeaveIfError( iEventHandlers.Append(handler) ); + CleanupStack::Pop( handler ); + + handler = CRadioEventHandler::NewLC(aEventObserver, *this, ERadioServPsFrequency); + User::LeaveIfError( iEventHandlers.Append(handler) ); + CleanupStack::Pop( handler ); + + handler = CRadioEventHandler::NewLC(aEventObserver, *this, ERadioServPsFrequencyRange); + User::LeaveIfError( iEventHandlers.Append(handler) ); + CleanupStack::Pop( handler ); + + handler = CRadioEventHandler::NewLC(aEventObserver, *this, ERadioServPsForceMonoReception); + User::LeaveIfError( iEventHandlers.Append(handler) ); + CleanupStack::Pop( handler ); + + handler = CRadioEventHandler::NewLC(aEventObserver, *this, ERadioServPsSquelch); + User::LeaveIfError( iEventHandlers.Append(handler) ); + CleanupStack::Pop( handler ); + + handler = CRadioEventHandler::NewLC(aEventObserver, *this, ERadioServPsVolume); + User::LeaveIfError( iEventHandlers.Append(handler) ); + CleanupStack::Pop( handler ); + + handler = CRadioEventHandler::NewLC(aEventObserver, *this, ERadioServPsMuteStatus); + User::LeaveIfError( iEventHandlers.Append(handler) ); + CleanupStack::Pop( handler ); + + handler = CRadioEventHandler::NewLC(aEventObserver, *this, ERadioServPsBalance); + User::LeaveIfError( iEventHandlers.Append(handler) ); + CleanupStack::Pop( handler ); + } + +// ----------------------------------------------------------------------------- +// RRadioSession::StartRdsEventHandlersL +// ----------------------------------------------------------------------------- +// +void RRadioSession::StartRdsEventHandlersL( + TUint32 aRdsFunction ) + { + FUNC_LOG; + + iRdsEventHandlers.ResetAndDestroy(); + CRadioEventHandler* handler = NULL; + + // If RDS notification started always return the latest RdsSignalStatus + handler = CRadioEventHandler::NewLC(*iObserver, *this, ERadioServPsRdsSignalStatus); + User::LeaveIfError( iRdsEventHandlers.Append(handler) ); + CleanupStack::Pop( handler ); + + handler = CRadioEventHandler::NewLC(*iObserver, *this, ERadioServPsAutoSwitchStatus); + User::LeaveIfError( iRdsEventHandlers.Append(handler) ); + CleanupStack::Pop( handler ); + + if (aRdsFunction & TRsRdsData::ERsRdsProgrammeIdentification) + { + handler = CRadioEventHandler::NewLC(*iObserver, *this, ERadioServPsProgrammeIdentification); + User::LeaveIfError( iRdsEventHandlers.Append(handler) ); + CleanupStack::Pop( handler ); + } + + if (aRdsFunction & TRsRdsData::ERsRdsProgrammeType) + { + handler = CRadioEventHandler::NewLC(*iObserver, *this,ERadioServPsProgrammeType ); + User::LeaveIfError( iRdsEventHandlers.Append(handler) ); + CleanupStack::Pop( handler ); + } + + if (aRdsFunction & TRsRdsData::ERsRdsProgrammeService) + { + handler = CRadioEventHandler::NewLC(*iObserver, *this, ERadioServPsProgrammeService); + User::LeaveIfError( iRdsEventHandlers.Append(handler) ); + CleanupStack::Pop( handler ); + } + + if(aRdsFunction & TRsRdsData::ERsRdsRadioText) + { + handler = CRadioEventHandler::NewLC(*iObserver, *this, ERadioServPsRadioText); + User::LeaveIfError( iRdsEventHandlers.Append(handler) ); + CleanupStack::Pop( handler ); + } + + if(aRdsFunction & TRsRdsData::ERsRdsRadioTextPlus) + { + handler = CRadioEventHandler::NewLC(*iObserver, *this, ERadioServPsRadioTextPlusObjects); + User::LeaveIfError( iRdsEventHandlers.Append(handler) ); + CleanupStack::Pop( handler ); + } + + if (aRdsFunction & TRsRdsData::ERsRdsClockTime) + { + handler = CRadioEventHandler::NewLC(*iObserver, *this, ERadioServPsClockTime); + User::LeaveIfError( iRdsEventHandlers.Append(handler) ); + CleanupStack::Pop( handler ); + } + + if (aRdsFunction & TRsRdsData::ERsRdsTrafficAnnouncement) + { + handler = CRadioEventHandler::NewLC(*iObserver, *this, ERadioServPsTrafficAnnouncementStatus); + User::LeaveIfError( iRdsEventHandlers.Append(handler) ); + CleanupStack::Pop( handler ); + } + + if (aRdsFunction & TRsRdsData::ERsRdsAlternateFrequency) + { + handler = CRadioEventHandler::NewLC(*iObserver, *this, ERadioServPsAfSearchBegin); + User::LeaveIfError( iRdsEventHandlers.Append(handler) ); + CleanupStack::Pop( handler ); + + handler = CRadioEventHandler::NewLC(*iObserver, *this, ERadioServPsAfSearchEnd); + User::LeaveIfError( iRdsEventHandlers.Append(handler) ); + CleanupStack::Pop( handler ); + } + } + +// End of File