/*
* 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 );
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool CRadioPubSubImp::PublishActivePreseListCount( TInt aCount ) const
    {
    return Set( KRadioPSDataActivePresetListCount, aCount );
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool CRadioPubSubImp::PublishActivePreseListFocus( TInt aIndex ) const
    {
    return Set( KRadioPSDataActivePresetListFocus, aIndex );
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool CRadioPubSubImp::PublishAntennaState( TRadioPSRadioAntennaState aState ) const
    {
    return Set( KRadioPSDataRadioAntennaState, aState );
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CRadioPubSubImp::SetControlEventObserver( MRadioControlEventObserver* aControlEventObserver )
    {
    iObserver = aControlEventObserver;
    }