--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/radioapp/radioenginewrapper/src/radioenginewrapper_p.cpp Fri Mar 19 09:29:04 2010 +0200
@@ -0,0 +1,327 @@
+/*
+* 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:
+*
+*/
+
+// System includes
+
+// User includes
+#include "radioenginewrapper_p.h"
+#include "radiosettings.h"
+#include "radiosettings_p.h"
+#include "radiologger.h"
+#include "radio_global.h"
+#include "cradioenginehandler.h"
+#include "radiofrequencyscanninghandler.h"
+#include "radiostationhandlerif.h"
+#include "cradiopubsub.h"
+#include "radiocontroleventlistener.h"
+#include "radiordslistener.h"
+#include "cradiorepositorymanager.h"
+#include "radioenginewrapperobserver.h"
+
+// Constants
+
+/*!
+ *
+ */
+RadioEngineWrapperPrivate::RadioEngineWrapperPrivate( RadioEngineWrapper* wrapper,
+ RadioStationHandlerIf& stationHandler,
+ RadioEngineWrapperObserver& observer ) :
+ q_ptr( wrapper ),
+ mStationHandler( stationHandler ),
+ mObserver( observer ),
+ mEngineHandler( new CRadioEngineHandler( *this ) ),
+ mControlEventListener( new RadioControlEventListener( *this ) ),
+ mRdsListener ( new RadioRdsListener( mStationHandler, *this ) ),
+ mCommandSender( 0 ),
+ mUseLoudspeaker( false ),
+ mIsSeeking( false )
+{
+}
+
+/*!
+ *
+ */
+RadioEngineWrapperPrivate::~RadioEngineWrapperPrivate()
+{
+ // Destructor needs to be defined because some member variables that are forward declared
+ // in the header are managed by QT's smart pointers and they require that the owning class
+ // has a non-inlined destructor. Compiler generates an inlined destructor if it isn't defined.
+}
+
+/*!
+ * Initializes the private implementation
+ */
+void RadioEngineWrapperPrivate::init()
+{
+ TRAPD( err, mEngineHandler->ConstructL() );
+ if ( err != KErrNone ) {
+ LOG_FORMAT( "RadioEngineWrapperPrivate::init, EngineHandler construct failed: %d", err );
+ mEngineHandler.reset();
+ return;
+ //TODO: Error handling?
+ }
+
+ mEngineHandler->SetRdsObserver( mRdsListener.data() );
+ mEngineHandler->PubSub().SetControlEventObserver( mControlEventListener.data() );
+ mControlEventListener->init();
+
+ // Start observing profile changes
+ mEngineHandler->Repository().AddEntityL( KCRUidProfileEngine,
+ KProEngActiveProfile,
+ CRadioRepositoryManager::ERadioEntityInt );
+
+ mUseLoudspeaker = mEngineHandler->IsAudioRoutedToLoudspeaker();
+ if ( !mUseLoudspeaker ) {
+ mObserver.audioRouteChanged( false );
+ }
+}
+
+/*!
+ * Starts up the radio engine
+ */
+bool RadioEngineWrapperPrivate::isEngineConstructed()
+{
+ return mEngineHandler != 0;
+}
+
+/*!
+ * Returns the settings handler owned by the engine
+ */
+RadioSettings& RadioEngineWrapperPrivate::settings()
+{
+ if ( !mSettings ) {
+ mSettings.reset( new RadioSettings() );
+ mSettings->d_func()->init( &mEngineHandler->ApplicationSettings() );
+ }
+ return *mSettings;
+}
+
+/*!
+ * Returns the enginehandler owned by the engine
+ */
+CRadioEngineHandler& RadioEngineWrapperPrivate::RadioEnginehandler()
+{
+ return *mEngineHandler;
+}
+
+/*!
+ * Tunes to the given frequency
+ */
+void RadioEngineWrapperPrivate::tuneFrequency( uint frequency, const int sender )
+{
+ mCommandSender = sender;
+ mEngineHandler->Tune( frequency );
+}
+
+/*!
+ * Tunes to the given frequency after a delay
+ */
+void RadioEngineWrapperPrivate::tuneWithDelay( uint frequency, const int sender )
+{
+ mCommandSender = sender;
+ mEngineHandler->TuneWithDelay( frequency );
+}
+
+/*!
+ *
+ */
+RadioEngineWrapperObserver& RadioEngineWrapperPrivate::observer()
+{
+ return mObserver;
+}
+
+/*!
+ *
+ */
+void RadioEngineWrapperPrivate::startSeeking( Seeking::Direction direction )
+{
+ mEngineHandler->Seek( direction );
+ mObserver.seekingStarted( direction );
+}
+
+/*!
+ * \reimp
+ */
+void RadioEngineWrapperPrivate::PowerEventL( TBool aPowerState, TInt DEBUGVAR( aError ) )
+{
+ LOG_FORMAT( "RadioEngineWrapperPrivate::PowerEventL, PowerState: %d, Error: %d", aPowerState, aError );
+ mObserver.radioStatusChanged( aPowerState );
+ mEngineHandler->PubSub().PublishPowerState( aPowerState );
+}
+
+/*!
+ * \reimp
+ */
+void RadioEngineWrapperPrivate::FrequencyEventL( TUint32 aFrequency,
+ RadioEngine::TRadioFrequencyEventReason aReason,
+ TInt aError )
+{
+ LOG_FORMAT( "RadioEngineWrapperPrivate::FrequencyEventL - Frequency: %d, Reason: %d, Error: %d", aFrequency, aReason, aError );
+
+ if ( mFrequencyScanningHandler )
+ {
+ // frequencyevents not handled during scanning //TODO remove
+ return;
+ }
+
+ if ( !aError ) {
+ const uint frequency = static_cast<uint>( aFrequency );
+
+ mStationHandler.setCurrentStation( frequency );
+ // Stations found by seeking (autotune) are saved as local stations
+// if ( aReason == RadioEngine::ERadioFrequencyEventReasonUp
+// || aReason == RadioEngine::ERadioFrequencyEventReasonDown )
+// {
+// mStationHandler.addScannedFrequency( frequency );
+// mIsSeeking = false;
+// mCommandSender = 0;
+// }
+
+ //mEngineHandler->SetMuted( EFalse );
+ LOG_TIMESTAMP( "Channel change finished" );
+
+ mObserver.tunedToFrequency( frequency, mCommandSender );
+
+ mStationHandler.startDynamicPsCheck();
+
+ mEngineHandler->PubSub().PublishFrequency( aFrequency );
+ }
+}
+
+/*!
+ * \reimp
+ */
+void RadioEngineWrapperPrivate::VolumeEventL( TInt aVolume, TInt aError )
+{
+ Q_UNUSED( aError );
+ mObserver.volumeChanged( aVolume );
+ mEngineHandler->PubSub().PublishVolume( aVolume );
+}
+
+/*!
+ * \reimp
+ */
+void RadioEngineWrapperPrivate::MuteEventL( TBool aMuteState, TInt aError )
+{
+ Q_UNUSED( aError );
+ mObserver.muteChanged( aMuteState );
+ mEngineHandler->PubSub().PublishRadioMuteState( aMuteState );
+}
+
+/*!
+ * \reimp
+ */
+void RadioEngineWrapperPrivate::AudioModeEventL( TInt DEBUGVAR( aAudioMode ), TInt DEBUGVAR( aError ) )
+{
+ LOG_FORMAT( "RadioEngineWrapperPrivate::AudioModeEventL, AudioMode: %d, Error: %d", aAudioMode, aError );
+}
+
+/*!
+ * \reimp
+ */
+void RadioEngineWrapperPrivate::AntennaEventL( TBool aAntennaAttached, TInt aError )
+{
+ Q_UNUSED( aError );
+ mObserver.headsetStatusChanged( aAntennaAttached );
+// doc->PubSubL().PublishHeadsetStatusL( EVRPSHeadsetConnected );
+}
+
+/*!
+ * \reimp
+ */
+void RadioEngineWrapperPrivate::AudioRoutingEventL( TInt aAudioDestination, TInt aError )
+{
+ //TODO: Check how this event differs from AudioRoutingChangedL
+ Q_UNUSED( aAudioDestination )
+ Q_UNUSED( aError )
+// doc->PubSubL().PublishLoudspeakerStatusL( EVRPSLoudspeakerNotInUse );
+// Q_Q( RadioEngineWrapper );
+// q->audioRouteChanged( aAudioDestination == RadioEngine::ERadioSpeaker );
+}
+
+/*!
+ * \reimp
+ */
+void RadioEngineWrapperPrivate::SeekingEventL( TInt aSeekingState, TInt DEBUGVAR( aError ) )
+{
+ LOG_FORMAT( "RadioEngineWrapperPrivate::SeekingEventL, aSeekingState: %d, Error: %d", aSeekingState, aError );
+ if ( aSeekingState != RadioEngine::ERadioNotSeeking ) {
+ // We only set the flag here. It is reset in the FrequencyEventL
+ mIsSeeking = true;
+ }
+// Document()->PubSubL().PublishTuningStateL( EVRPSTuningStarted );
+}
+
+/*!
+ * \reimp
+ */
+void RadioEngineWrapperPrivate::RegionEventL( TInt DEBUGVAR( aRegion ), TInt DEBUGVAR( aError ) )
+{
+ LOG_FORMAT( "RadioEngineWrapperPrivate::RegionEventL, aRegion: %d, Error: %d", aRegion, aError );
+// Document()->PubSubL().PublishFrequencyDecimalCountL(
+// static_cast<TVRPSFrequencyDecimalCount>( Document()->RadioSettings()->DecimalCount() ) );
+}
+
+/*!
+ * \reimp
+ */
+void RadioEngineWrapperPrivate::AudioRouteChangedL( RadioEngine::TRadioAudioRoute aRoute )
+{
+ mUseLoudspeaker = aRoute == RadioEngine::ERadioSpeaker;
+ mObserver.audioRouteChanged( mUseLoudspeaker );
+}
+
+/*!
+ * \reimp
+ */
+void RadioEngineWrapperPrivate::HandleSystemEventL( TRadioSystemEventType DEBUGVAR( aEventType ) )
+{
+ LOG_FORMAT( "RadioEngineWrapperPrivate::HandleSystemEventL, Event: %d", aEventType );
+// ERadioHeadsetConnected, ///< Headset was connected
+// ERadioHeadsetDisconnected, ///< Headset was disconnected
+// ERadioNetworkCoverageUp, ///< Network coverage detected
+// ERadioNetworkCoverageDown, ///< Network coverage lost
+// ERadioCallActivated, ///< Call activated or ringing
+// ERadioCallDeactivated, ///< Call disconnected
+// ERadioEmergencyCallActivated, ///< Call activated or ringing
+// ERadioEmergencyCallDeactivated, ///< Call disconnected
+// ERadioLowDiskSpace, ///< Low disk space
+// ERadioAudioRoutingHeadset, ///< Audio routed through headset
+// ERadioAudioRoutingSpeaker, ///< Audio routed through speaker ( IHF )
+// ERadioAudioResourcesAvailable, ///< Audio resources have become available
+// ERadioAudioAutoResumeForbidden ///< Audio auto resuming is forbidden
+}
+
+/*!
+ * \reimp
+ */
+void RadioEngineWrapperPrivate::HandleRepositoryValueChangeL( const TUid& aUid, TUint32 aKey, TInt aValue, TInt aError )
+{
+ if ( aUid == KCRUidProfileEngine && aKey == KProEngActiveProfile && !aError && aValue == KOfflineProfileId ) {
+ LOG( "RadioEngineWrapperPrivate::HandleRepositoryValueChangeL: Offline profile activated" );
+ }
+}
+
+/*!
+ *
+ */
+void RadioEngineWrapperPrivate::frequencyScannerFinished()
+{
+ RadioFrequencyScanningHandler* handler = mFrequencyScanningHandler.take(); // Nulls the pointer
+ handler->deleteLater();
+ mObserver.scanAndSaveFinished();
+}