/*
* 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:  The RDS receiver implementation for FM Radio
*
*/


#include "fmradiordsreceiverbase.h"
#include "fmradiopubsub.h"
#include "fmradioengineradiosettings.h"

// The delay, in microseconds, after which RDS PS name is concidered static
const TInt KFMRadioStaticRdsPsNameDelay = 10000000; 

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

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::CFMRadioRdsReceiverBase
// ---------------------------------------------------------------------------
//
CFMRadioRdsReceiverBase::CFMRadioRdsReceiverBase( TRadioSettings& aSettings ) : iSettings(aSettings)
    {
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::BaseConstructL
// ---------------------------------------------------------------------------
//
void CFMRadioRdsReceiverBase::BaseConstructL()
    {
    iPsName = HBufC::NewL( TRdsPSName().MaxLength() );
    iRadioText = HBufC::NewL( TRdsRadioText().MaxLength() );
    iPsNameTimer = CPeriodic::NewL( CActive::EPriorityStandard );
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::~CFMRadioRdsReceiverBase
// ---------------------------------------------------------------------------
//
CFMRadioRdsReceiverBase::~CFMRadioRdsReceiverBase()
    {
    iObservers.Close();
    delete iPsName;
    delete iRadioText;
    delete iPsNameTimer;
    
    iProgramWebUrl.Close();
    iArtistName.Close();
    iSongName.Close();
    iAlbumName.Close();
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::AddObserver
// ---------------------------------------------------------------------------
//
EXPORT_C void CFMRadioRdsReceiverBase::AddObserver( MFMRadioRdsObserver* aObserver )
    {
    TInt index = iObservers.FindInAddressOrder( aObserver );
    if( index == KErrNotFound )
        {
        iObservers.InsertInAddressOrder( aObserver );
        }
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::RemoveObserver
// ---------------------------------------------------------------------------
//
EXPORT_C void CFMRadioRdsReceiverBase::RemoveObserver( MFMRadioRdsObserver* aObserver )
    {
    TInt index = iObservers.FindInAddressOrder( aObserver );

    if( index >= 0 )
        {
        iObservers.Remove( index );
        }
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::AutomaticSwitchingEnabled
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CFMRadioRdsReceiverBase::AutomaticSwitchingEnabled() const
    {
    return iAfEnabled;
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::ProgrammeService
// ---------------------------------------------------------------------------
//
EXPORT_C const TDesC& CFMRadioRdsReceiverBase::ProgrammeService() const
    {
    return *iPsName;
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::ProgrammeServiceNameType
// ---------------------------------------------------------------------------
//
EXPORT_C CFMRadioRdsReceiverBase::TFMRadioProgrammeSeviceType CFMRadioRdsReceiverBase::ProgrammeServiceNameType() const
    {
    return iPsNameType;
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::SignalAvailable
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CFMRadioRdsReceiverBase::SignalAvailable() const
    {
    return iSignalAvailable;
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::RtPlusWebUrl
// ---------------------------------------------------------------------------
//
EXPORT_C const TDesC& CFMRadioRdsReceiverBase::RtPlusProgramUrl() const
    {
    return iProgramWebUrl;
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::RtPlusArtist
// ---------------------------------------------------------------------------
//
EXPORT_C const TDesC& CFMRadioRdsReceiverBase::RtPlusArtist() const
    {
    return iArtistName;
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::RtPlusAlbum
// ---------------------------------------------------------------------------
//
EXPORT_C const TDesC& CFMRadioRdsReceiverBase::RtPlusAlbum() const
    {
    return iAlbumName;
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::RtPlusSong
// ---------------------------------------------------------------------------
//
EXPORT_C const TDesC& CFMRadioRdsReceiverBase::RtPlusSong() const
    {
    return iSongName;
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::SetAutomaticSwitchingL
// ---------------------------------------------------------------------------
//
void CFMRadioRdsReceiverBase::SetAutomaticSwitchingL( TBool aEnable )
    {
    iAfEnabled = aEnable;
    for( TInt i = 0 ; i < iObservers.Count() ; i++ )
        {
        iObservers[i]->RdsAfSearchStateChange( iAfEnabled );
        }
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::ClearRdsInformation
// ---------------------------------------------------------------------------
//
void CFMRadioRdsReceiverBase::ClearRdsInformation()
    {
    TRdsPSName name;
    TRdsRadioText radioText;
    iPsNameTimer->Cancel();
    iPsNameType = EFMRadioPSNameStaticAssumed;
    MrroRdsDataPS( name );
    MrroRdsDataRT( radioText );
    iProgramWebUrl.Close();
    iArtistName.Close();
    iSongName.Close();
    iAlbumName.Close();
    MrroRdsEventSignalChange( EFalse );
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::StaticPsNameTimerCallback
// ---------------------------------------------------------------------------
//
TInt CFMRadioRdsReceiverBase::StaticPsNameTimerCallback( TAny* aSelf )
    {
    CFMRadioRdsReceiverBase* self = static_cast<CFMRadioRdsReceiverBase*>( aSelf );
    if( self )
        {
        self->iPsNameTimer->Cancel();
        if ( self->iPsNameType == EFMRadioPSNameStaticAssumed )
            {
            self->iPsNameType = EFMRadioPSNameStatic;
            for( TInt i = 0 ; i < self->iObservers.Count() ; i++ )
                {
                self->iObservers[i]->RdsDataPsNameIsStatic( ETrue );
                }
            }
        }
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::HandleRdsDataRTplusL
// ---------------------------------------------------------------------------
//
void CFMRadioRdsReceiverBase::HandleRdsDataRTplusL( TRdsRTplusClass aRtPlusClass, TRdsRadioText& aRtPlusData )
    {
    TBool dataChanged = EFalse;
    switch (aRtPlusClass)
        {
        case ERTplusItemTitle:
            if ( aRtPlusData != iSongName )
                {
                dataChanged = ETrue;
                iSongName.Close();
                iSongName.CreateL( aRtPlusData );
                }
            break;
        case ERTplusItemArtist:
        case ERTplusItemBand:
            if ( aRtPlusData != iArtistName )
                {
                dataChanged = ETrue;
                iArtistName.Close();
                iArtistName.CreateL( aRtPlusData );
                }
            break;
        case ERTplusItemAlbum:
            if ( aRtPlusData != iAlbumName )
                {
                dataChanged = ETrue;
                iAlbumName.Close();
                iAlbumName.CreateL( aRtPlusData );
                }
            break;
        case ERTplusProgramHomepage:
            {
            if ( aRtPlusData != iProgramWebUrl )
                {
                dataChanged = ETrue;
                iProgramWebUrl.Close();
                iProgramWebUrl.CreateL( aRtPlusData );
                }
            break;
            }
        default:
            // Let uncached values go through
            dataChanged = ETrue;
            break;
        }
    
    if ( dataChanged )
        {
        for( TInt i = 0 ; i < iObservers.Count() ; i++ )
            {
            iObservers[i]->RdsDataRadioTextPlus( aRtPlusClass, aRtPlusData );
            }
        }
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::MrroStationSeekByPTYComplete
// ---------------------------------------------------------------------------
//
void CFMRadioRdsReceiverBase::MrroStationSeekByPTYComplete( TInt /*aError*/, TInt /*aFrequency*/ )
    {
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::MrroStationSeekByTAComplete
// ---------------------------------------------------------------------------
//
void CFMRadioRdsReceiverBase::MrroStationSeekByTAComplete( TInt /*aError*/, TInt /*aFrequency*/ )
    {
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::MrroStationSeekByTPComplete
// ---------------------------------------------------------------------------
//
void CFMRadioRdsReceiverBase::MrroStationSeekByTPComplete( TInt /*aError*/, TInt /*aFrequency*/ )
    {
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::MrroGetFreqByPTYComplete
// ---------------------------------------------------------------------------
//
void CFMRadioRdsReceiverBase::MrroGetFreqByPTYComplete( TInt /*aError*/, RArray<TInt>& /*aFreqList*/ )
    {
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::MrroGetFreqByTAComplete
// ---------------------------------------------------------------------------
//
void CFMRadioRdsReceiverBase::MrroGetFreqByTAComplete( TInt /*aError*/, RArray<TInt>& /*aFreqList*/ )
    {
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::MrroGetPSByPTYComplete
// ---------------------------------------------------------------------------
//
void CFMRadioRdsReceiverBase::MrroGetPSByPTYComplete( TInt /*aError*/, RArray<TRdsPSName>& /*aPsList*/ )
    {
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::MrroGetPSByTAComplete
// ---------------------------------------------------------------------------
//
void CFMRadioRdsReceiverBase::MrroGetPSByTAComplete( TInt /*aError*/, RArray<TRdsPSName>& /*aPsList*/ )
    {
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::MrroRdsDataPI
// ---------------------------------------------------------------------------
//
void CFMRadioRdsReceiverBase::MrroRdsDataPI( TInt /*aPi*/ )
    {
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::MrroRdsDataPTY
// ---------------------------------------------------------------------------
//
void CFMRadioRdsReceiverBase::MrroRdsDataPTY( TRdsProgrammeType /*aPty*/ )
    {
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::MrroRdsDataPS
// Notifies of the New Programme Service data
// ---------------------------------------------------------------------------
//
void CFMRadioRdsReceiverBase::MrroRdsDataPS( TRdsPSName& aPs )
    {
    TBool reportStaticState = EFalse;
    if ( iPsName->Length() && aPs.Length() )
        {
        if ( *iPsName != aPs && iPsNameTimer->IsActive() )
            {
            // PS existed and it changed, cancel the timer as it is not static name anymore
            iPsNameTimer->Cancel();
            iPsNameType = EFMRadioPSNameDynamic;
            reportStaticState = ETrue;
            }
        else
            {
            if ( iPsNameType == EFMRadioPSNameStaticAssumed && !iPsNameTimer->IsActive() )
                {
                // The timer should be reactivated in order to complete the determination
                iPsNameTimer->Start( KFMRadioStaticRdsPsNameDelay, 
                                     0, 
                                     TCallBack( CFMRadioRdsReceiverBase::StaticPsNameTimerCallback, this ) );
                }
            }
        }
    else if ( !iPsName->Length() && aPs.Length() )
        {
        // PS name is set for the first time, start the timer to see if it is a static one
        iPsNameTimer->Cancel();
        iPsNameTimer->Start( KFMRadioStaticRdsPsNameDelay, 
                             0, 
                             TCallBack( CFMRadioRdsReceiverBase::StaticPsNameTimerCallback, this ) );
        }
    else
        {
        // PS name is reset
        }
    
    iPsName->Des().Copy( aPs );
    
    if ( iPubSub )
        {
        TRAP_IGNORE( iPubSub->PublishRDSProgramServiceL( *iPsName ));
        }
 
    for( TInt i = 0 ; i < iObservers.Count() ; i++ )
        {
        iObservers[i]->RdsDataProgrammeService( *iPsName );
        if( reportStaticState )
            {
            iObservers[i]->RdsDataPsNameIsStatic( iPsNameType == EFMRadioPSNameStatic );
            }
        }
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::MrroRdsDataRT
// ---------------------------------------------------------------------------
//
void CFMRadioRdsReceiverBase::MrroRdsDataRT( TRdsRadioText& aRt )
    { 
    iRadioText->Des().Copy( aRt );
    for( TInt i = 0 ; i < iObservers.Count() ; i++ )
        {
        iObservers[i]->RdsDataRadioText( *iRadioText );
        }
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::MrroRdsDataCT
// ---------------------------------------------------------------------------
//
void CFMRadioRdsReceiverBase::MrroRdsDataCT( TDateTime& /*aCt*/ )
    {
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::MrroRdsDataTA
// ---------------------------------------------------------------------------
//
void CFMRadioRdsReceiverBase::MrroRdsDataTA( TBool /*aTaOn*/ )
    {
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::MrroRdsDataRTplus
// ---------------------------------------------------------------------------
//
void CFMRadioRdsReceiverBase::MrroRdsDataRTplus( TRdsRTplusClass aRtPlusClass, TRdsRadioText& aRtPlusData )
    {
    TRAP_IGNORE( HandleRdsDataRTplusL( aRtPlusClass, aRtPlusData ) )
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::MrroRdsSearchBeginAF
// Notifies of the start of Alternate Frequency search
// ---------------------------------------------------------------------------
//
void CFMRadioRdsReceiverBase::MrroRdsSearchBeginAF()
    {
    for( TInt i = 0 ; i < iObservers.Count() ; i++ )
        {
        iObservers[i]->RdsAfSearchBegin();
        }
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::MrroRdsSearchBeginAF
// Notifies of the end of Alternate Frequency search
// ---------------------------------------------------------------------------
//
void CFMRadioRdsReceiverBase::MrroRdsSearchEndAF( TInt aError, TInt aFrequency )
    {
    for( TInt i = 0 ; i < iObservers.Count() ; i++ )
        {
        // Radio utility uses Hz, UI uses kHz. It's ok to divide with 1000, possible lost fractions are useless.
        iObservers[i]->RdsAfSearchEnd( aFrequency / KFMRadioFreqMultiplier, aError );
        }
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::MrroRdsStationChangeTA
// ---------------------------------------------------------------------------
//
void CFMRadioRdsReceiverBase::MrroRdsStationChangeTA( TInt /*aFrequency*/ )
    {
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::MrroRdsEventAutomaticSwitchingChange
// ---------------------------------------------------------------------------
//
void CFMRadioRdsReceiverBase::MrroRdsEventAutomaticSwitchingChange( TBool /*aAuto*/ )
    {
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::MrroRdsEventAutomaticTrafficAnnouncement
// ---------------------------------------------------------------------------
//
void CFMRadioRdsReceiverBase::MrroRdsEventAutomaticTrafficAnnouncement( TBool /*aAuto*/ )
    {
    }

// ---------------------------------------------------------------------------
// CFMRadioRdsReceiverBase::MrroRdsEventSignalChange
// ---------------------------------------------------------------------------
//
void CFMRadioRdsReceiverBase::MrroRdsEventSignalChange( TBool aSignal )
    {
    if ( aSignal )
        {
        if ( iPsName->Length() )
            {
            if ( iPsNameType == EFMRadioPSNameStaticAssumed && !iPsNameTimer->IsActive() )
                {
                iPsNameTimer->Cancel();
                iPsNameTimer->Start( KFMRadioStaticRdsPsNameDelay, 
                                     0, 
                                     TCallBack( CFMRadioRdsReceiverBase::StaticPsNameTimerCallback, this ) );
                }
            }
        }
    else
        {
        // PS name type determination must be canceled on bad signal
        iPsNameTimer->Cancel();
        }
    iSignalAvailable = aSignal;
    for( TInt i = 0 ; i < iObservers.Count() ; i++ )
        {
        iObservers[i]->RdsAvailable( iSignalAvailable );
        }
    }