/*

* Copyright (c) 2005-2007 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:  Publish&Subscribe component of FM Radio

*

*/

#include "fmradiocontroleventobserver.h"

#include "fmradiopubsub.h"

// ================= MEMBER FUNCTIONS =======================

// ---------------------------------------------------------------------------

// C++ default constructor can NOT contain any code, that might leave.

// ---------------------------------------------------------------------------

//

CFMRadioPubSub::CFMRadioPubSub()

    {

    }

// ---------------------------------------------------------------------------

// EPOC default constructor can leave.

// ---------------------------------------------------------------------------

//

void CFMRadioPubSub::ConstructL()

    {    

    // Define data properties.

    DefinePropertyL( KFMRadioPSDataChannel, RProperty::EInt, ETrue );

    DefinePropertyL( KFMRadioPSDataFrequency, RProperty::EInt, ETrue );

    DefinePropertyL( KFMRadioPSDataRadioPowerState, RProperty::EInt, ETrue );

    DefinePropertyL( KFMRadioPSDataVolume, RProperty::EInt, ETrue );

    DefinePropertyL( KFMRadioPSDataChannelDataChanged, RProperty::EInt, ETrue );

    DefinePropertyL( KFMRadioPSDataTuningState, RProperty::EInt, ETrue );

    DefinePropertyL( KFMRadioPSDataRadioMuteState, RProperty::EInt, ETrue );

    DefinePropertyL( KFMRadioPSDataApplicationRunning, RProperty::EInt, ETrue );

    DefinePropertyL( KFMRadioPSDataHeadsetStatus, RProperty::EInt, ETrue );

    DefinePropertyL( KFMRadioPSDataFrequencyDecimalCount, RProperty::EInt, ETrue );

    DefinePropertyL( KFMRadioPSDataLoudspeakerStatus, RProperty::EInt, ETrue );

    DefinePropertyL( KFMRadioPSDataRDSProgramService, RProperty::EText, ETrue );

    DefinePropertyL( KFMRadioPSDataRDSRadioText, RProperty::EText, ETrue );

    DefinePropertyL( KFMRadioPSDataChannelName, RProperty::EText, ETrue );

    // Define control properties.

    DefinePropertyL( KFMRadioPSControlStepToChannel, RProperty::EInt, EFalse );

    DefinePropertyL( KFMRadioPSControlSeek, RProperty::EInt, EFalse );

    DefinePropertyL( KFMRadioPSControlSetRadioMuteState , RProperty::EInt, EFalse );

    // Observe control properties.

    DefinePropertyL( KFMRadioActiveIdlePresetListCount, RProperty::EInt, ETrue );    

    DefinePropertyL( KFMRadioActiveIdlePresetListFocus, RProperty::EInt, ETrue );

    CFMRadioPropertyObserver* observer = CFMRadioPropertyObserver::NewLC( *this,

            KFMRadioPSUid, KFMRadioPSControlStepToChannel, CFMRadioPropertyObserver::EFMRadioPropertyInt);

    iPropertyArray.AppendL( observer );

    CleanupStack::Pop( observer );

    observer = CFMRadioPropertyObserver::NewLC( *this,

            KFMRadioPSUid, KFMRadioPSControlSeek, CFMRadioPropertyObserver::EFMRadioPropertyInt );

    iPropertyArray.AppendL( observer );

    CleanupStack::Pop( observer );

    observer = CFMRadioPropertyObserver::NewLC( *this,

            KFMRadioPSUid, KFMRadioPSControlSetRadioMuteState, CFMRadioPropertyObserver::EFMRadioPropertyInt );

    iPropertyArray.AppendL( observer );

    CleanupStack::Pop( observer );

    observer = CFMRadioPropertyObserver::NewLC( *this,

            KFMRadioPSUid, KFMRadioActiveIdlePresetListCount, CFMRadioPropertyObserver::EFMRadioPropertyInt );

    iPropertyArray.AppendL( observer );

    CleanupStack::Pop( observer );

    for ( TInt i = 0; i < iPropertyArray.Count(); i++ )

		{

		iPropertyArray[i]->ActivateL();	

		}

    }

// -------------------------------------------------------f--------------------

// Two-phased constructor.

// ---------------------------------------------------------------------------

//

CFMRadioPubSub* CFMRadioPubSub::NewL()

    {

    CFMRadioPubSub* self = new (ELeave) CFMRadioPubSub();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//

CFMRadioPubSub::~CFMRadioPubSub()

    {

    iPropertyArray.ResetAndDestroy();

	iPropertyArray.Close();

	DeleteProperty( KFMRadioPSDataChannel );

	DeleteProperty( KFMRadioPSDataFrequency );

	DeleteProperty( KFMRadioPSDataRadioPowerState );

	DeleteProperty( KFMRadioPSDataVolume );

	DeleteProperty( KFMRadioPSDataChannelDataChanged );

	DeleteProperty( KFMRadioPSDataTuningState );

	DeleteProperty( KFMRadioPSDataRadioMuteState );

	DeleteProperty( KFMRadioPSDataApplicationRunning );

    DeleteProperty( KFMRadioPSDataHeadsetStatus );

    DeleteProperty( KFMRadioPSDataFrequencyDecimalCount );

    DeleteProperty( KFMRadioPSDataLoudspeakerStatus );

    DeleteProperty( KFMRadioPSDataRDSProgramService );

    DeleteProperty( KFMRadioPSDataRDSRadioText );

    DeleteProperty( KFMRadioPSDataChannelName );

	DeleteProperty( KFMRadioPSControlStepToChannel );

	DeleteProperty( KFMRadioPSControlSeek );

	DeleteProperty( KFMRadioPSControlSetRadioMuteState );

    DeleteProperty ( KFMRadioActiveIdlePresetListCount);

	DeleteProperty ( KFMRadioActiveIdlePresetListFocus);

    }

// ---------------------------------------------------------------------------

// Defines a property.

// ---------------------------------------------------------------------------

//

void CFMRadioPubSub::DefinePropertyL( TUint aKey, TInt aAttr, TBool aDataProperty ) const

    {

    /*lint -save -e648*/

    _LIT_SECURITY_POLICY_PASS( KFMRadioExternalAccessPolicy );

    /*lint -restore*/

    _LIT_SECURITY_POLICY_S0( KFMRadioInternalAccessPolicy, KUidFMRadioApplication );

    TInt err = KErrNone;

    if ( aDataProperty )

        {   

        // For data properties, grant read access for all, but write access only for FMRadioEngine

        err = RProperty::Define( KFMRadioPSUid, aKey, aAttr, KFMRadioExternalAccessPolicy, KFMRadioInternalAccessPolicy );

        }

    else

        {

        // For control properties, grant read access only for FMRadioEngine , but write access for all

        err = RProperty::Define( KFMRadioPSUid, aKey, aAttr, KFMRadioInternalAccessPolicy, KFMRadioExternalAccessPolicy );

        }

    if ( err && err != KErrAlreadyExists )

        {

        User::Leave( err );

        }

    }

// ---------------------------------------------------------------------------

// Deletes a property

// ---------------------------------------------------------------------------

//

void CFMRadioPubSub::DeleteProperty( TUint aKey ) const

    {

    RProperty::Delete( KFMRadioPSUid, aKey );

    }

// ---------------------------------------------------------------------------

// Gets the integer value stored in a property.

// ---------------------------------------------------------------------------

//

TInt CFMRadioPubSub::PropertyValueIntL( TUint aKey ) const

    {

    TInt value;

    User::LeaveIfError( RProperty::Get( KFMRadioPSUid, aKey, value ) );

    return value;

    }

// ---------------------------------------------------------------------------

// Sets a property's value.

// ---------------------------------------------------------------------------

//

void CFMRadioPubSub::SetPropertyValueL( TUint aKey, TInt aValue ) const

    {

    User::LeaveIfError( RProperty::Set( KFMRadioPSUid, aKey, aValue ) );

    }

// ---------------------------------------------------------------------------

// Sets a text property value

// ---------------------------------------------------------------------------

//

void CFMRadioPubSub::SetPropertyValueL( TUint aKey, const TDesC& aValue ) const

    {

    User::LeaveIfError( RProperty::Set( KFMRadioPSUid, aKey, aValue ) );

    }

// ---------------------------------------------------------------------------

// CFMRadioPubSub::HandlePropertyChangeL

// ---------------------------------------------------------------------------

//

void CFMRadioPubSub::HandlePropertyChangeL( const TUid& aCategory, const TUint aKey, const TInt aValue )

	{		

	if (aCategory != KFMRadioPSUid)

		{

		User::Leave(KErrArgument);

		}

	if (iObserver)

		{

		if (aKey == KFMRadioPSControlStepToChannel)

	    	{

	    	switch (aValue)

	    		{

				case EFMRadioPSStepToChannelUninitialized:

					{

					break;	

					}

				case EFMRadioPSStepToChannelUp:

					{

					iObserver->StepToChannelL(EFMRadioUp);

					break;

					}

				case EFMRadioPSStepToChannelDown:

					{

					iObserver->StepToChannelL(EFMRadioDown);

					break;

					}

	 			default:

	 				{

	 				break; 

	 				}			

	    		}

	    	}

	    else if (aKey == KFMRadioPSControlSeek)

	    	{

	    	switch (aValue)

	    		{

				case EFMRadioPSSeekUninitialized:

					{

					break;	

					}

				case EFMRadioPSSeekUp:

					{

					iObserver->SeekL(EFMRadioUp);

					break;

					}

				case EFMRadioPSSeekDown:

					{

					iObserver->SeekL(EFMRadioDown);

					break;

					}

	 			default:

	 				{

	 				break; 

	 				}			

	    		}

	    	}

	    else if (aKey == KFMRadioPSControlSetRadioMuteState)

	    	{

	    	switch (aValue)

	    		{

				case EFMRadioPSMuteStateUninitialized:

					{

					break;	

					}

				case EFMRadioPSMuteStateOn:

					{

					iObserver->MuteL(ETrue);

					break;

					}

				case EFMRadioPSMuteStateOff:

					{

					iObserver->MuteL(EFalse);

					break;

					}

	 			default:

	 				{

	 				break; 

	 				}			

	    		}

	    	}

		}

	}

// ---------------------------------------------------------------------------

// Currently empty implementation because we don't listen byte array type properties.

// ---------------------------------------------------------------------------

//

void CFMRadioPubSub::HandlePropertyChangeL(const TUid& /*aCategory*/, const TUint /*aKey*/, const TDesC8& /*aValue*/)

	{

	}

// ---------------------------------------------------------------------------

// Currently empty implementation because we don't listen text type properties.

// ---------------------------------------------------------------------------

//

void CFMRadioPubSub::HandlePropertyChangeL(const TUid& /*aCategory*/, const TUint /*aKey*/, const TDesC& /*aValue*/)

	{

	}

// ---------------------------------------------------------------------------

// CFMRadioPubSub::HandlePropertyChangeErrorL

// ---------------------------------------------------------------------------

//

void CFMRadioPubSub::HandlePropertyChangeErrorL (const TUid& /*aCategory*/, const TUint /*aKey*/, TInt /*aError*/ )

	{

	//NOP

	}

// ---------------------------------------------------------------------------

// CFMRadioPubSub::PublishChannelL

// ---------------------------------------------------------------------------

//	

void CFMRadioPubSub::PublishChannelL(TInt aChannelId) const

	{	    

    TInt oldChannelId = PropertyValueIntL( KFMRadioPSDataChannel );

    if ( aChannelId != oldChannelId )

        {

    	SetPropertyValueL( KFMRadioPSDataChannel, aChannelId );

        }

	}

// ---------------------------------------------------------------------------

// CFMRadioPubSub::PublishFrequencyL

// ---------------------------------------------------------------------------

//	

EXPORT_C void CFMRadioPubSub::PublishFrequencyL( TUint32 aFreq ) const

	{	

    TInt oldFreq = PropertyValueIntL( KFMRadioPSDataFrequency );

    if ( aFreq != oldFreq )

        {

    	SetPropertyValueL( KFMRadioPSDataFrequency, aFreq );

        }

	}

// ---------------------------------------------------------------------------

// CFMRadioPubSub::PublishStateL

// ---------------------------------------------------------------------------

//	

EXPORT_C void CFMRadioPubSub::PublishStateL( TBool aPowerOn ) const

	{	

    // If application process gets killed, power on state remains published.

    // Must not compare state transition here, because then power on might not be published.

	TFMRadioPSRadioPowerState newState = aPowerOn ? EFMRadioPSRadioPowerOn : EFMRadioPSRadioPowerOff;

    SetPropertyValueL( KFMRadioPSDataRadioPowerState, newState );

	}

// ---------------------------------------------------------------------------

// CFMRadioPubSub::PublishVolumeL

// ---------------------------------------------------------------------------

//	

void CFMRadioPubSub::PublishVolumeL( TInt aVol ) const

	{	

	TInt oldVol = PropertyValueIntL( KFMRadioPSDataVolume );

	if ( aVol != oldVol )

	    {

    	SetPropertyValueL( KFMRadioPSDataVolume, aVol );

	    }

	}

// ---------------------------------------------------------------------------

// CFMRadioPubSub::PublishPresetCountL

// ---------------------------------------------------------------------------

//	

EXPORT_C void CFMRadioPubSub::PublishPresetCountL( TInt aVal ) const

	{	

	TInt oldVal = PropertyValueIntL( KFMRadioActiveIdlePresetListCount );

	if ( aVal != oldVal )

	    {

    	SetPropertyValueL( KFMRadioActiveIdlePresetListCount, aVal );

	    }

	}

// ---------------------------------------------------------------------------

// CFMRadioPubSub::PublishChannelDataChangedL

// ---------------------------------------------------------------------------

//	

void CFMRadioPubSub::PublishChannelDataChangedL( TInt aChannelId ) const

	{		

	// Channel data changed notifications are allowed for the same channel multiple times, as the same channel's

	// data can be changed many times in a row.

	SetPropertyValueL( KFMRadioPSDataChannelDataChanged, aChannelId );

	}

// ---------------------------------------------------------------------------

// CFMRadioPubSub::PublishTuningStateL

// ---------------------------------------------------------------------------

//	

void CFMRadioPubSub::PublishTuningStateL( TFMRadioPSTuningState aTuningState ) const

    {	

    TFMRadioPSTuningState oldState = static_cast<TFMRadioPSTuningState>( PropertyValueIntL( KFMRadioPSDataTuningState ) );

	if ( aTuningState != oldState )

	    {

        SetPropertyValueL( KFMRadioPSDataTuningState, aTuningState );

	    }

    }

// ---------------------------------------------------------------------------

// CFMRadioPubSub::PublishMuteStateL

// ---------------------------------------------------------------------------

//

void CFMRadioPubSub::PublishRadioMuteStateL( TBool aMuted ) const

	{

	TFMRadioPSRadioMuteState oldState = static_cast<TFMRadioPSRadioMuteState>( PropertyValueIntL( KFMRadioPSDataRadioMuteState ) );

	TFMRadioPSRadioMuteState newState = aMuted ? EFMRadioPSMuteStateOn : EFMRadioPSMuteStateOff;

	if ( newState != oldState )

	    {

        SetPropertyValueL( KFMRadioPSDataRadioMuteState, newState );

	    }

	}

// ---------------------------------------------------------------------------

// CFMRadioPubSub::PublishApplicationRunningStateL

// ---------------------------------------------------------------------------

//

EXPORT_C void CFMRadioPubSub::PublishApplicationRunningStateL( TFMRadioPSApplicationRunningState aRunningState ) const

	{	

    // If application process gets killed, wrong running state remains published.

    // Must not compare state transition here, because then application start might not be published.

    SetPropertyValueL( KFMRadioPSDataApplicationRunning, aRunningState );

	}

// ---------------------------------------------------------------------------

// CFMRadioPubSub::PublishAntennaStatusL

// ---------------------------------------------------------------------------

//

void CFMRadioPubSub::PublishAntennaStatusL( TFMRadioPSHeadsetStatus aAntennaStatus ) const

	{	

    TFMRadioPSHeadsetStatus oldState = static_cast<TFMRadioPSHeadsetStatus>( PropertyValueIntL( KFMRadioPSDataHeadsetStatus ) );

	if ( aAntennaStatus != oldState )

	    {

        SetPropertyValueL( KFMRadioPSDataHeadsetStatus, aAntennaStatus );

	    }

	}

// ---------------------------------------------------------------------------

// CFMRadioPubSub::PublishFrequencyDecimalCountL

// ---------------------------------------------------------------------------

//

void CFMRadioPubSub::PublishFrequencyDecimalCountL( TFMRadioPSFrequencyDecimalCount aDecimalCount ) const

	{	

    TFMRadioPSFrequencyDecimalCount oldCount = static_cast<TFMRadioPSFrequencyDecimalCount>( PropertyValueIntL( KFMRadioPSDataFrequencyDecimalCount ) );

	if ( aDecimalCount != oldCount )

	    {

        SetPropertyValueL( KFMRadioPSDataFrequencyDecimalCount, aDecimalCount );

	    }

	}

// ---------------------------------------------------------------------------

// CFMRadioPubSub::PublishLoudspeakerStatusL

// ---------------------------------------------------------------------------

//

void CFMRadioPubSub::PublishLoudspeakerStatusL( 

    TFMRadioPSLoudspeakerStatus aLoudspeakerStatus ) const

    {

    TFMRadioPSLoudspeakerStatus oldLoudspeakerStatus 

        = static_cast<TFMRadioPSLoudspeakerStatus>( 

        PropertyValueIntL(KFMRadioPSDataLoudspeakerStatus) );

    if(oldLoudspeakerStatus != aLoudspeakerStatus)

        {

        SetPropertyValueL( KFMRadioPSDataLoudspeakerStatus, aLoudspeakerStatus);

        }	

	}

// ---------------------------------------------------------------------------

// CFMRadioPubSub::PublishRDSProgramServiceL

// ---------------------------------------------------------------------------

//

EXPORT_C void CFMRadioPubSub::PublishRDSProgramServiceL( const TDesC& aProgramService ) const

    {

    SetPropertyValueL( KFMRadioPSDataRDSProgramService, aProgramService );

	}

// ---------------------------------------------------------------------------

// CFMRadioPubSub::PublishRDSRadioTextL

// ---------------------------------------------------------------------------

//

EXPORT_C void CFMRadioPubSub::PublishRDSRadioTextL( const TDesC& aRadioText ) const

    {

    SetPropertyValueL( KFMRadioPSDataRDSRadioText, aRadioText );

    }

// ---------------------------------------------------------------------------

// CFMRadioPubSub::PublishChannelNameL

// ---------------------------------------------------------------------------

//

EXPORT_C void CFMRadioPubSub::PublishChannelNameL( const TDesC& aName ) const

    {

    SetPropertyValueL( KFMRadioPSDataChannelName, aName );

    }

// ---------------------------------------------------------------------------

// CFMRadioPubSub::SetControlEventObserver

// ---------------------------------------------------------------------------

//

EXPORT_C void CFMRadioPubSub::SetControlEventObserver( MFMRadioControlEventObserver* aControlEventObserver )

    {

    iObserver = aControlEventObserver;

    }