/*

* 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:

*

*/

#include "radiouid.hrh"

#include "cradioenginelogger.h"

#include "radiointernalpskeys.h"

#include "mradiocontroleventobserver.h"

#include "cradiopubsub.h"

#include "cradiopubsubimp.h"

#include "radioengineutils.h"

// This has to be the last include. 

#ifdef STUB_CONSTELLATION

#   include "RadioStubManager.h"

#   define KRadioPSUid KStub_KRadioPSUid

#endif //STUB_CONSTELLATION

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

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

//

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

//

CRadioPubSubImp::CRadioPubSubImp()

    {

    }

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

//

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

//

void CRadioPubSubImp::ConstructL()

    {

    RadioEngineUtils::InitializeL();

    LOG_METHOD_AUTO;

    // Define data properties.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // Define control properties.

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

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

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

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

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

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

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

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

    // Observe control properties.

    CreatePropertyObserverL( KRadioPSControlStepToChannel,      CRadioPropertyObserver::ERadioPropertyInt );

    CreatePropertyObserverL( KRadioPSControlSetChannel,         CRadioPropertyObserver::ERadioPropertyInt );

    CreatePropertyObserverL( KRadioPSControlSeek,               CRadioPropertyObserver::ERadioPropertyInt );

    CreatePropertyObserverL( KRadioPSControlStepToFrequency,    CRadioPropertyObserver::ERadioPropertyInt );

    CreatePropertyObserverL( KRadioPSControlSetFrequency,       CRadioPropertyObserver::ERadioPropertyInt );

    CreatePropertyObserverL( KRadioPSControlAdjustVolume,       CRadioPropertyObserver::ERadioPropertyInt );

    CreatePropertyObserverL( KRadioPSControlSetRadioMuteState,  CRadioPropertyObserver::ERadioPropertyInt );

    CreatePropertyObserverL( KRadioPSControlSetAudioOutput,     CRadioPropertyObserver::ERadioPropertyInt );

    }

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

//

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

//

CRadioPubSubImp* CRadioPubSubImp::NewL()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

//

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

//

CRadioPubSubImp::~CRadioPubSubImp()

    {

    iPropertyArray.ResetAndDestroy();

    DeleteProperty( KRadioPSDataChannel );

    DeleteProperty( KRadioPSDataFrequency );

    DeleteProperty( KRadioPSDataRadioPowerState );

    DeleteProperty( KRadioPSDataVolume );

    DeleteProperty( KRadioPSDataChannelDataChanged );

    DeleteProperty( KRadioPSDataTuningState );

    DeleteProperty( KRadioPSDataRadioMuteState );

    DeleteProperty( KRadioPSDataApplicationRunning );

    DeleteProperty( KRadioPSDataHeadsetStatus );

    DeleteProperty( KRadioPSDataFrequencyDecimalCount );

    DeleteProperty( KRadioPSDataLoudspeakerStatus );

    DeleteProperty( KRadioPSDataRdsProgramService );

    DeleteProperty( KRadioPSDataRdsRadioText );

    DeleteProperty( KRadioPSDataChannelName );

    DeleteProperty( KRadioPSDataActivePresetListCount );

    DeleteProperty( KRadioPSDataActivePresetListFocus );

    DeleteProperty( KRadioPSDataRadioAntennaState );

    DeleteProperty( KRadioPSControlStepToChannel );

    DeleteProperty( KRadioPSControlSetChannel );

    DeleteProperty( KRadioPSControlSeek );

    DeleteProperty( KRadioPSControlStepToFrequency );

    DeleteProperty( KRadioPSControlSetFrequency );

    DeleteProperty( KRadioPSControlAdjustVolume );

    DeleteProperty( KRadioPSControlSetRadioMuteState );

    DeleteProperty( KRadioPSControlSetAudioOutput );

    RadioEngineUtils::Release();

    }

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

// Defines a property.

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

//

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

    {

    _LIT_SECURITY_POLICY_PASS( KRadioExternalAccessPolicy );

    _LIT_SECURITY_POLICY_S0( KRadioInternalAccessPolicy, KUidRadioApplication );

    TInt err = KErrNone;

    if ( aDataProperty )

        {

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

        err = RProperty::Define( KRadioPSUid, aKey, aAttr, KRadioExternalAccessPolicy, KRadioInternalAccessPolicy );

        }

    else

        {

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

        err = RProperty::Define( KRadioPSUid, aKey, aAttr, KRadioInternalAccessPolicy, KRadioExternalAccessPolicy );

        }

    if ( err && err != KErrAlreadyExists )

        {

        LOG_FORMAT( "CRadioPubSubImp::DefinePropertyL: Leaving with %d", err );

        User::Leave( err );

        }

    }

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

// Deletes a property

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

//

void CRadioPubSubImp::DeleteProperty( TUint aKey ) const

    {

    RProperty::Delete( KRadioPSUid, aKey );

    }

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

// Creates a property observer

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

//

void CRadioPubSubImp::CreatePropertyObserverL( const TUint aKey,

                                               const TInt aPropertyType )

    {

    CRadioPropertyObserver* observer = CRadioPropertyObserver::NewL( *this, KRadioPSUid,

                    aKey, static_cast<CRadioPropertyObserver::TRadioPropertyType>( aPropertyType ) );

    if ( iPropertyArray.Append( observer ) == KErrNone )

        {

        observer->ActivateL();

        }

    else

        {

        delete observer;

        observer = NULL;

        }

    }

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

// Gets the integer value stored in a property.

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

//

TBool CRadioPubSubImp::Get( TUint aKey, TInt& aValue ) const

    {

    return RProperty::Get( KRadioPSUid, aKey, aValue ) == KErrNone;

    }

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

// Sets a property's value.

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

//

TBool CRadioPubSubImp::Set( TUint aKey, TInt aValue ) const

    {

    return RProperty::Set( KRadioPSUid, aKey, aValue ) == KErrNone;

    }

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

// Sets a text property value

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

//

TBool CRadioPubSubImp::Set( TUint aKey, const TDesC& aValue ) const

    {

    return RProperty::Set( KRadioPSUid, aKey, aValue ) == KErrNone;

    }

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

//

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

//

void CRadioPubSubImp::HandlePropertyChangeL( const TUid& aCategory,

                                             const TUint aKey,

                                             const TInt aValue )

    {

    LOG_FORMAT( "CRadioPubSubImp::HandlePropertyChangeL: Category: %d, Key: %u. Value: %d",

                                                aCategory.iUid, aKey, aValue );

    if ( aCategory != KRadioPSUid )

        {

        LOG( "CRadioPubSubImp::HandlePropertyChangeL: Unknown category. Leaving" );

        User::Leave( KErrArgument );

        }

    if ( !iObserver )

        {

        return;

        }

    if ( aKey == KRadioPSControlStepToChannel )

        {

        if ( aValue == ERadioPSStepToChannelUp )

            {

            iObserver->StepToChannelL( RadioEngine::ERadioUp );

            }

        else if ( aValue == ERadioPSStepToChannelDown )

            {

            iObserver->StepToChannelL( RadioEngine::ERadioDown );

            }

        }

    else if ( aKey == KRadioPSControlSetChannel )

        {

        if ( aValue > 0 )

            {

            iObserver->SetChannelL( aValue );

            }

        }

    else if ( aKey == KRadioPSControlSeek )

        {

        if ( aValue == ERadioPSSeekUp )

            {

            iObserver->SeekL( RadioEngine::ERadioUp );

            }

        else if ( aValue == ERadioPSSeekDown )

            {

            iObserver->SeekL( RadioEngine::ERadioDown );

            }

        }

    else if ( aKey == KRadioPSControlStepToFrequency )

        {

        if ( aValue == ERadioPSStepToFrequencyUp )

            {

            iObserver->StepToFrequencyL( RadioEngine::ERadioUp );

            }

        else if ( aValue == ERadioPSStepToFrequencyDown )

            {

            iObserver->StepToFrequencyL( RadioEngine::ERadioDown );

            }

        }

    else if ( aKey == KRadioPSControlSetFrequency )

        {

        if ( aValue > 0 )

            {

            iObserver->SetFrequencyL( aValue );

            }

        }

    else if ( aKey == KRadioPSControlAdjustVolume )

        {

        if ( aValue == ERadioPSIncreaseVolume )

            {

            iObserver->AdjustVolumeL( RadioEngine::ERadioIncVolume );

            }

        else if ( aValue == ERadioPSDecreaseVolume )

            {

            iObserver->AdjustVolumeL( RadioEngine::ERadioDecVolume );

            }

        }

    else if ( aKey == KRadioPSControlSetRadioMuteState )

        {

        if ( aValue == ERadioPSMuteStateOn )

            {

            iObserver->MuteL( ETrue );

            }

        else if ( aValue == ERadioPSMuteStateOff )

            {

            iObserver->MuteL( EFalse );

            }

        }

    else if ( aKey == KRadioPSControlSetAudioOutput )

        {

        if ( aValue == ERadioPSAudioOutputHeadset )

            {

            iObserver->SetAudioRouteL( RadioEngine::ERadioHeadset );

            }

        else if ( aValue == ERadioPSAudioOutputSpeaker )

            {

            iObserver->SetAudioRouteL( RadioEngine::ERadioSpeaker );

            }

        }

    }

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

//

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

//

TBool CRadioPubSubImp::PublishChannel( TInt aChannelId ) const

    {

    LOG_FORMAT( "CRadioPubSubImp::PublishChannel ( aChannelId = %d )", aChannelId );

    TInt oldChannelId = 0;

    if ( Get( KRadioPSDataChannel, oldChannelId ) && aChannelId != oldChannelId )

        {

        return Set( KRadioPSDataChannel, aChannelId );

        }

    return EFalse;

    }

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

//

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

//

TBool CRadioPubSubImp::PublishFrequency( TUint32 aFreq ) const

    {

    LOG_FORMAT( "CRadioPubSubImp::PublishFrequency ( aFreq = %u )", aFreq );

    TInt oldFreq = 0;

    if ( Get( KRadioPSDataFrequency, oldFreq ) && aFreq != oldFreq )

        {

        return Set( KRadioPSDataFrequency, aFreq );

        }

    return EFalse;

    }

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

//

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

//

TBool CRadioPubSubImp::PublishPowerState( TBool aPowerOn ) const

    {

    LOG_FORMAT( "CRadioPubSubImp::PublishStateL ( aPowerOn = %d )", aPowerOn );

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

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

    TRadioPSRadioPowerState newState = aPowerOn ? ERadioPSRadioPowerOn : ERadioPSRadioPowerOff;

    return Set( KRadioPSDataRadioPowerState, newState );

    }

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

//

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

//

TBool CRadioPubSubImp::PublishVolume( TInt aVol ) const

    {

    LOG_FORMAT( "CRadioPubSubImp::PublishVolume ( aVol = %d )", aVol );

    TInt oldVol = 0;

    if ( Get( KRadioPSDataVolume, oldVol ) && aVol != oldVol )

        {

        return Set( KRadioPSDataVolume, aVol );

        }

    return EFalse;

    }

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

//

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

//

TBool CRadioPubSubImp::PublishChannelDataChanged( TInt aChannelId ) const

    {

    LOG_FORMAT( "CRadioPubSubImp::PublishChannelDataChangedL ( aChannelId = %d )", aChannelId );

    // 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.

    return Set( KRadioPSDataChannelDataChanged, aChannelId );

    }

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

//

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

//

TBool CRadioPubSubImp::PublishTuningState( TRadioPSTuningState aTuningState ) const

    {

    LOG_FORMAT( "CRadioPubSubImp::PublishSeekingStateL ( aTuningState = %d )", aTuningState );

    TInt oldState = 0;

    if ( Get( KRadioPSDataTuningState, oldState ) && aTuningState != oldState )

        {

        return Set( KRadioPSDataTuningState, aTuningState );

        }

    return EFalse;

    }

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

//

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

//

TBool CRadioPubSubImp::PublishRadioMuteState( TBool aMuted ) const

    {

    LOG_FORMAT( "CRadioPubSubImp::PublishMuteStateL ( aMuted = %d )", aMuted );

    TRadioPSRadioMuteState newState = aMuted ? ERadioPSMuteStateOn : ERadioPSMuteStateOff;

    TInt oldState = 0;

    if ( Get( KRadioPSDataRadioMuteState, oldState ) && oldState != newState )

        {

        return Set( KRadioPSDataRadioMuteState, newState );

        }

    return EFalse;

    }

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

//

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

//

TBool CRadioPubSubImp::PublishApplicationRunningState( TRadioPSApplicationRunningState aRunningState ) const

    {

    LOG_FORMAT( "CRadioPubSubImp::PublishApplicationRunningStateL ( aRunningState = %d )", aRunningState );

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

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

    return Set( KRadioPSDataApplicationRunning, aRunningState );

    }

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

//

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

//

TBool CRadioPubSubImp::PublishHeadsetStatus( TRadioPSHeadsetStatus aHeadsetStatus ) const

    {

    LOG_FORMAT( "CRadioPubSubImp::PublishHeadsetStatusL ( aHeadsetStatus = %d )", aHeadsetStatus );

    TInt oldStatus = 0;

    if ( Get( KRadioPSDataHeadsetStatus, oldStatus ) && aHeadsetStatus != oldStatus )

        {

        return Set( KRadioPSDataHeadsetStatus, aHeadsetStatus );

        }

    return EFalse;

    }

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

//

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

//

TBool CRadioPubSubImp::PublishFrequencyDecimalCount( TRadioPSFrequencyDecimalCount aDecimalCount ) const

    {

    LOG_FORMAT( "CRadioPubSubImp::PublishFrequencyDecimalCountL ( aDecimalCount = %d )", aDecimalCount );

    TInt oldCount = 0;

    if ( Get( KRadioPSDataFrequencyDecimalCount, oldCount ) && aDecimalCount != oldCount )

        {

        return Set( KRadioPSDataFrequencyDecimalCount, aDecimalCount );

        }

    return EFalse;

    }

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

//

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

//

TBool CRadioPubSubImp::PublishLoudspeakerStatus( TRadioPSLoudspeakerStatus aLoudspeakerStatus ) const

    {

    LOG_FORMAT( "CRadioPubSubImp::PublishLoudspeakerStatusL ( aLoudspeakerStatus = %d )", aLoudspeakerStatus );

    TInt oldStatus = 0;

    if ( Get( KRadioPSDataLoudspeakerStatus, oldStatus ) && oldStatus != aLoudspeakerStatus )

        {

        return Set( KRadioPSDataLoudspeakerStatus, aLoudspeakerStatus );

        }

    return EFalse;

    }

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

//

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

//

TBool CRadioPubSubImp::PublishRdsProgramService( const TDesC& aProgramService ) const

    {

    return Set( KRadioPSDataRdsProgramService, aProgramService );

    }

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

//

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

//

TBool CRadioPubSubImp::PublishRdsRadioText( const TDesC& aRadioText ) const

    {

    return Set( KRadioPSDataRdsRadioText, aRadioText );

    }

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

//

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

//

TBool CRadioPubSubImp::PublishChannelName( const TDesC& aName ) const

    {

    return Set( KRadioPSDataChannelName, aName );

    }

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