MCL/sf/app/radio: comparison fmradio/fmradioengine/src/fmradioengine.cpp

equal deleted inserted replaced

-:9f3ff466f56b
+:4f2584af5a29
 //  INCLUDE FILES
 #include <AudioOutput.h>
 #include <AccMonitor.h>
 #include <bautils.h>
 #include <coemain.h>
-#include <ctsydomainpskeys.h>
 #include <data_caging_path_literals.hrh>
-#include <e32property.h>
 #include "fmradioengine.h"
 #include "fmradioenginestatechangecallback.h"
 #include "debug.h"
 #include "fmradioengineradiosettings.h"
 // ----------------------------------------------------
 //
 CRadioEngine::CRadioEngine(
 MRadioEngineStateChangeCallback& aCallback)
 :
-iAutoResume(EFalse),
+iCurrentRadioState( EStateRadioOff ),
-iCurrentRadioState(EStateRadioOff),
+iCallback( aCallback ),
-iCallback(aCallback),
+iTempFrequency( KDefaultRadioFrequency ),
-iTempFrequency(KDefaultRadioFrequency),
+iTunePresetRequested( EFalse ),
-iTunePresetRequested(EFalse),
+iInitializeRadioRequestExists( EFalse ),
-iInitializeRadioRequestExists(EFalse),
+iTunerControl( EStateRadioTunerControlUninitialized )
-ilineConstructed( EFalse ),
-iHFOptionActivated ( EFalse )
 {
 }
 // ----------------------------------------------------
 // CRadioEngine::ConstructL
 // ----------------------------------------------------
 //
 void CRadioEngine::ConstructL()
 {
 FTRACE(FPrint(_L("CRadioEngine::ConstructL()")));
-TRAP_IGNORE( ConnectLineL() );
 InitializeResourceLoadingL();
 iRadioSettings = new ( ELeave ) TRadioSettings;
 iCentralRepositoryHandler = CCentralRepositoryHandler::NewL( *iRadioSettings );
 // FM Radio is a primary client
 iRadioUtility = CRadioUtility::NewL( ETrue );
 // Get a tuner utility
 iFmTunerUtility = &iRadioUtility->RadioFmTunerUtilityL( *this );
+iFmTunerUtility->EnableTunerInOfflineMode( ETrue );
 // Get a player utility
 iPlayerUtility = &iRadioUtility->RadioPlayerUtilityL( *this );
 TInt maxVolume = 0;
 #endif
 iTopFrequency = 0;
 iBottomFrequency = 0;
-TInt callState = KErrUnknown;
+if ( iSystemEventDetector->IsCallActive() )
-RMobileCall::TMobileCallStatus linestatus;
+{
-	iLine.GetMobileLineStatus( linestatus );
+// Pre-empted due to phone call
-RProperty::Get(KPSUidCtsyCallInformation, KCTsyCallState, callState);
-// check status from line
-if ( linestatus != RMobileCall::EStatusIdle &&
-linestatus != RMobileCall::EStatusUnknown )
-{
-// Pre-empted due to phone call, start Call State Observer
 iInCall = ETrue;
 }
 // accessory observer
 iHeadsetObserver = CFMRadioAccessoryConnection::NewL();
 iHeadsetObserver->SetObserver( this );
 iPubSub->PublishFrequencyDecimalCountL(
 TFMRadioPSFrequencyDecimalCount( iRadioSettings->DecimalCount() ) );
 FTRACE(FPrint(_L("CRadioEngine::ConstructL() End ")));
 }
-// ----------------------------------------------------
-// CRadioEngine::ConnectLineL
-// Connects etel server
-// ----------------------------------------------------
-//
-void CRadioEngine::ConnectLineL()
-	{
-	User::LeaveIfError( iTelServer.Connect() );
-	iTelServer.GetTsyName( 0, iTsyName );
-	User::LeaveIfError( iTelServer.LoadPhoneModule( iTsyName ) );
-	TInt numberOfPhones( 0 );
-	User::LeaveIfError( iTelServer.EnumeratePhones( numberOfPhones ) );
-	RTelServer::TPhoneInfo phoneInfo;
-	// Only possible thing to do is leave. We definately need phone.
-	User::LeaveIfError( iTelServer.GetPhoneInfo( 0, phoneInfo ) );
-	// Only possible thing to do is leave. We definately need phone.
-	User::LeaveIfError( iPhone.Open( iTelServer, phoneInfo.iName ));
-	RPhone::TLineInfo lineInfo;
-	User::LeaveIfError( iPhone.GetLineInfo( 0, lineInfo ) );
-	User::LeaveIfError( iLine.Open( iPhone, lineInfo.iName ) );
-	ilineConstructed = ETrue;
-	}
 // ----------------------------------------------------
 // CRadioEngine::NewL
 // Two-phased class constructor.
 // ----------------------------------------------------
 	if ( iFMRadioEngineResourceOffset > 0 )
 {
 CCoeEnv::Static()->DeleteResourceFile( iFMRadioEngineResourceOffset );
 }
-	if ( ilineConstructed )
-		{
-		iLine.Close();
-	    iPhone.Close();
-	    iTelServer.UnloadPhoneModule( iTsyName );
-	    iTelServer.Close();
-	    }
 }
 // ----------------------------------------------------
 // CRadioEngine::InitializeRadio
 // Set radio settings to their default values.
 {
 FTRACE(FPrint(_L("CRadioEngine::Tune()")));
 iTempFrequency = aFrequency;
 iRadioSettings->SetRadioMode( aRadioMode );
-if ( iTunerControl && iRadioSettings->IsHeadsetConnected() )
+if ( iTunerControl == EStateRadioTunerControlOn && iRadioSettings->IsHeadsetConnected() )
 {
 iFmTunerUtility->SetFrequency( aFrequency );
 }
 else
 {
 // ----------------------------------------------------
 // CRadioEngine::MrftoRequestTunerControlComplete
 // ----------------------------------------------------
 //
-void CRadioEngine::MrftoRequestTunerControlComplete(
+void CRadioEngine::MrftoRequestTunerControlComplete( TInt aError )
-TInt aError )
 {
 FTRACE(FPrint(_L("CRadioEngine::MrftoRequestTunerControlComplete() - Error = %d"), aError));
 if ( aError == KErrNone )
 {
-iTunerControl = ETrue;
+iTunerControl = EStateRadioTunerControlOn;
 // Headset must be connected
 iRadioSettings->SetHeadsetConnected();
 iFmTunerUtility->GetCapabilities( iTunerCaps );
 if( iTunerCaps.iTunerFunctions & TFmTunerCapabilities::ETunerRdsSupport )
-	        {
+{
-	        TRAP_IGNORE( iRdsReceiver->InitL( *iRadioUtility, iPubSub ) )
+TRAP_IGNORE( iRdsReceiver->InitL( *iRadioUtility, iPubSub ) )
-	        }
+}
-		TFmRadioFrequencyRange japanFreqRange = EFmRangeJapan;
+TFmRadioFrequencyRange japanFreqRange = EFmRangeJapan;
+if ( TunerFrequencyRangeForRegionId( RegionId() ) == japanFreqRange )
-		if ( TunerFrequencyRangeForRegionId( RegionId() ) == japanFreqRange )
+{
-			{
+// region is Japan so we need to change the freq range from the default
-			// region is Japan so we need to change the freq range from the default
+iFmTunerUtility->SetFrequencyRange( japanFreqRange );
-			iFmTunerUtility->SetFrequencyRange( japanFreqRange );
+}
-			}
+else
-		else
+{
-			{
+// allready on correct freq range
-			// allready on correct freq range
+HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventTunerReady, KErrNone );
-			HandleCallback(MRadioEngineStateChangeCallback::EFMRadioEventTunerReady, KErrNone );
+}
-			}
 }
 else if ( aError == KFmRadioErrAntennaNotConnected )
 {
 FTRACE(FPrint(_L("CRadioEngine::MrftoRequestTunerControlComplete() - KFmRadioErrAntennaNotConnected")));
+iTunerControl = EStateRadioTunerControlOff;
 iRadioSettings->SetHeadsetDisconnected();
 HandleCallback(MRadioEngineStateChangeCallback::EFMRadioEventHeadsetDisconnected, KErrNone );
 }
 else if ( aError == KErrAlreadyExists )
 {
-iTunerControl = ETrue;
+iTunerControl = EStateRadioTunerControlOn;
 // Headset must be connected
 iRadioSettings->SetHeadsetConnected();
 iFmTunerUtility->GetCapabilities( iTunerCaps );
 TInt frequency;
 iFmTunerUtility->GetFrequency( frequency );
 StoreAndPublishFrequency( frequency );
 HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventTune, KErrNone );
 }
 else if ( aError == KFmRadioErrFmTransmitterActive )
 {
-iTunerControl = EFalse;
+iTunerControl = EStateRadioTunerControlOff;
 HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventFMTransmitterOn, KErrNone );
 }
 else if ( aError == KFmRadioErrOfflineMode )
 {
-iTunerControl = EFalse;
+iTunerControl = EStateRadioTunerControlOff;
 HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventFlightModeEnabled, KErrNone );
 }
 else
 {
-//pass
+iTunerControl = EStateRadioTunerControlOff;
 }
 }
 // ----------------------------------------------------
 // CRadioEngine::MrftoSetFrequencyRangeComplete
 //
 // ----------------------------------------------------
 //
-void CRadioEngine::MrftoSetFrequencyRangeComplete(
+void CRadioEngine::MrftoSetFrequencyRangeComplete( TInt aError )
-TInt aError )
 {
 if ( aError == KErrNone )
-	{
+{
-	HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventTunerReady, KErrNone );
+HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventTunerReady, KErrNone );
-	}
+}
 FTRACE(FPrint(_L("CRadioEngine::MrftoSetFrequencyRangeComplete() - error = %d"), aError));
 }
 // ----------------------------------------------------
 // CRadioEngine::MrftoSetFrequencyComplete
 // ----------------------------------------------------
 //
-void CRadioEngine::MrftoSetFrequencyComplete(
+void CRadioEngine::MrftoSetFrequencyComplete( TInt aError )
-TInt aError )
 {
 FTRACE(FPrint(_L("CRadioEngine::MrftoSetFrequencyComplete() - aError = %d"), aError));
 if ( !aError )
 {
 iRdsReceiver->ClearRdsInformation();
 StoreAndPublishFrequency( iTempFrequency );
 iInitializeRadioRequestExists = EFalse;
 FTRACE(FPrint(_L("CRadioEngine::MrftoSetFrequencyComplete() - Sending event to UI")));
 HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventTune, aError );
 }
 }
 // ----------------------------------------------------
 // CRadioEngine::MrftoStationSeekComplete
 //
 {
 FTRACE(FPrint(_L("CRadioEngine::MrftoFmTransmitterStatusChange() - Active = %d"), aActive));
 if ( aActive )
 {
 // loses tuner control
-iTunerControl = EFalse;
+iTunerControl = EStateRadioTunerControlOff;
 }
 }
 // ----------------------------------------------------
 TBool aAttached )
 {
 FTRACE(FPrint(_L("CRadioEngine::MrftoAntennaStatusChange() - Antenna Status = %d"), aAttached));
 if ( aAttached )
 {
-if ( !iTunerControl )
+if ( iTunerControl == EStateRadioTunerControlOff )
 {
 iFmTunerUtility->RequestTunerControl();
 }
 iRadioSettings->SetHeadsetConnected();
 TRAP_IGNORE( iPubSub->PublishAntennaStatusL( EFMRadioPSHeadsetConnected ) );
 // ----------------------------------------------------
 // CRadioEngine::FlightModeChanged
 // Called when offline mode status changes
 // ----------------------------------------------------
 //
-void CRadioEngine::MrftoOfflineModeStatusChange(
+void CRadioEngine::MrftoOfflineModeStatusChange( TBool aOfflineMode )
-TBool aOfflineMode )
 {
 FTRACE(FPrint(_L("CRadioEngine::MrftoOfflineModeStatusChange() - Offline Mode = %d"), aOfflineMode));
-if( aOfflineMode )
+if ( aOfflineMode )
 {
 HandleFlightModeEnabled();
 }
 else
 {
-if ( !iTunerControl )
+if ( iTunerControl == EStateRadioTunerControlOff )
 {
 iFmTunerUtility->RequestTunerControl();
 }
 HandleFlightModeDisabled();
 }
 if ( ( aError == KErrDied ) ||
 ( aError == KErrAccessDenied ) ||
 ( aError == KErrNotReady ) ||
 ( aError == KErrInUse ) )
 {
-TInt callState = KErrUnknown;
+// check call status
+if ( iSystemEventDetector->IsCallActive() )
-RMobileCall::TMobileCallStatus linestatus;
-if ( ilineConstructed )
-					{
-	iLine.GetMobileLineStatus( linestatus );
-	}
-FTRACE(FPrint(_L("CRadioEngine::MrpoStateChange() linestatus = %d"), linestatus));
-TInt err = RProperty::Get(KPSUidCtsyCallInformation, KCTsyCallState, callState);
-FTRACE(FPrint(_L("CRadioEngine::MrpoStateChange() callState = %d"), callState));
-// check status from line
-if ( linestatus != RMobileCall::EStatusIdle &&
-linestatus != RMobileCall::EStatusUnknown ||
-iSystemEventDetector->IsCallActive() )
 {
-FTRACE(FPrint(_L("CRadioEngine::MrpoStateChange() EFMRadioEventCallStarted")  ) );
+FTRACE(FPrint(_L("CRadioEngine::MrpoStateChange() EFMRadioEventCallStarted") ) );
 iInCall = ETrue;
 ret = MRadioEngineStateChangeCallback::EFMRadioEventCallStarted;
 }
 }
 else if ( aError == KErrHardwareNotAvailable ) // Radio is interrupted by FM Transmitter activation.
 // CRadioEngine::AudioResourcesAvailableL
 // This callback notifies when audio resources become available.
 // -----------------------------------------------------------------------------
 //
 void CRadioEngine::AudioResourcesAvailableL()
-	{
+{
-	FTRACE( FPrint( _L("CRadioEngine::AudioResourcesAvailableL()" ) ) );
+FTRACE( FPrint( _L("CRadioEngine::AudioResourcesAvailableL()" ) ) );
-	if ( iPubSub && !iInCall && iTunerControl ) // if iPubSub exists, then the ConstructL has been successfully completed
+// if iPubSub exists, then the ConstructL has been successfully completed
-		{
+if ( iPubSub && !iInCall && iTunerControl == EStateRadioTunerControlOn )
-	    HandleCallback(MRadioEngineStateChangeCallback::EFMRadioEventAudioResourceAvailable, KErrNone );
+{
-		}
+HandleCallback(MRadioEngineStateChangeCallback::EFMRadioEventAudioResourceAvailable, KErrNone );
-	}
+}
+}
 // -----------------------------------------------------------------------------
 // CRadioEngine::AudioAutoResumeForbiddenL
 // This callback notifies when audio auto resuming is forbidden.
 // -----------------------------------------------------------------------------
 // CRadioEngine::CallActivatedCallbackL
 // This callback notifies when call becomes active.
 // -----------------------------------------------------------------------------
 //
 void CRadioEngine::CallActivatedCallbackL()
-	{
+{
-	FTRACE( FPrint( _L("CRadioEngine::CallActivatedCallbackL()" ) ) );
+FTRACE( FPrint( _L("CRadioEngine::CallActivatedCallbackL()" ) ) );
-	// no implementation needed, CRadioEngine::MrpoStateChange handles call startup
+iInCall = ETrue;
-	}
+}
 // -----------------------------------------------------------------------------
 // CRadioEngine::CallDeactivatedCallbackL
 // This callback notifies when call becomes deactive.
 // -----------------------------------------------------------------------------
 //
 // CRadioEngine::RequestTunerControl
 // request tuner control from RadioFmTunerUtility
 // ----------------------------------------------------
 //
 EXPORT_C void CRadioEngine::RequestTunerControl() const
-	{
+{
-	// Before first RequestTunerControl() call it is ok to enable offline mode without checking capabilities
+FTRACE( FPrint( _L("CRadioEngine::RequestTunerControl()")) );
-iFmTunerUtility->EnableTunerInOfflineMode( ETrue );
+if ( iTunerControl == EStateRadioTunerControlUninitialized )
-iFmTunerUtility->RequestTunerControl();
+{
-	}
+// first request for tuner control.
+iFmTunerUtility->RequestTunerControl();
+}
+}
 // ----------------------------------------------------
 // CRadioEngine::DecimalCount
 // return decimal count for current region MHz information
 // ----------------------------------------------------

branch	RCL_3
changeset 13	4f2584af5a29
parent 11	97dcae98e602