/*

* 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: Implementation for the FM Radio Content Publisher Plugin.

*

*/

#include <AknUtils.h>

#include <bautils.h>

#include <coemain.h>

#include <data_caging_path_literals.hrh>

#include <data_caging_paths_strings.hrh>

#include <e32cmn.h>

#include <ecom/implementationproxy.h>

#include <liwvariant.h>

#include <StringLoader.h>

#include <AknsConstants.h>

#include <AknsItemID.h>

#include <fmradiomcpplugin.rsg>

#include <fmradio.mbg>

#include "fmradioactionhandler.h"

#include "fmradioactionhandler.hrh"

#include "fmradioactionhandlerdefs.h"

#include "fmradioactiveidleengine.h"

#include "fmradioactiveidleenginenotifyhandler.h"

#include "fmradiodefines.h"

#include "debug.h"

#include "fmradiomcpplugin.h"

#include "fmradiomcpplugin.hrh"

_LIT( KFMRadioMifFileName, "fmradio.mif" );

_LIT( KFMRadioMifDir, "\\resource\\apps\\" );

_LIT( KFMRadioMCPPluginResourceFileName, "fmradiomcpplugin.rsc" );

_LIT8( KFMRadioPluginUid, "plugin_id" );

_LIT8( KFMRadioData, "data" );

_LIT8( KType, "type" );

const TUint KFMRadioPrevious        = 0x001; //000000000001

const TUint KFMRadioNext            = 0x002; //000000000010

const TUint KFMRadioMute            = 0x004; //000000000100

const TUint KFMRadioUnmute          = 0x008; //000000001000

const TUint KFMRadioPreviousDimmed  = 0x010; //000000010000

const TUint KFMRadioNextDimmed      = 0x020; //000000100000

const TUint KFMRadioMuteDimmed      = 0x040; //000001000000

const TUint KFMRadioUnmuteDimmed    = 0x080; //000010000000

CFMRadioMCPPlugin* CFMRadioMCPPlugin::NewL( MMCPPluginObserver* aObserver )

    {

    CFMRadioMCPPlugin* self = new ( ELeave ) CFMRadioMCPPlugin( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

CFMRadioMCPPlugin::~CFMRadioMCPPlugin()

    {

    if ( iResourceOffset > 0 )

        {

        CCoeEnv::Static()->DeleteResourceFile( iResourceOffset );

        }

    delete iEngine;

    iAntennaNotConnectedText.Close();

    iTuningText.Close();

    iSavedStationFormat.Close();

    iSavedStationFormatNoName.Close();

    iFrequencyFormat.Close();

    iMifFileName.Close();

    }

CFMRadioMCPPlugin::CFMRadioMCPPlugin( MMCPPluginObserver* aObserver )

    : iObserver( aObserver )

    {

    }

void CFMRadioMCPPlugin::ConstructL()

    {

    FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::ConstructL" )));

    InitializeResourceLoadingL();

    CCoeEnv* coeEnv = CCoeEnv::Static();

    iAntennaNotConnectedText.Assign( StringLoader::LoadL( R_QTN_FMRADIO_WIDGET_CON_HEADSET, coeEnv ) );

    iTuningText.Assign( StringLoader::LoadL( R_QTN_FMRADIO_WIDGET_TUNING, coeEnv ) );

    iSavedStationFormat.Assign( StringLoader::LoadL( R_QTN_FMRADIO_WIDGET_STATION_SAVED, coeEnv ) );

    iSavedStationFormatNoName.Assign( StringLoader::LoadL( R_QTN_FMRADIO_WIDGET_STATION_SAVED_FREQ, coeEnv ) );

    iFrequencyFormat.Assign( StringLoader::LoadL( R_QTN_FMRADIO_WIDGET_NOTSAVED_FREQUENCY, coeEnv ) );

    // Release the resource file, because we don't want to keep file handle open.

    // That would prevent updating the binary with SIS. 

    if ( iResourceOffset > 0 )

        {

        coeEnv->DeleteResourceFile( iResourceOffset );

        iResourceOffset = 0;

        }

    TFindFile finder( coeEnv->FsSession() );

    TInt err = finder.FindByDir( KFMRadioMifFileName, KFMRadioMifDir );

    if ( err == KErrNone )

        {

        iMifFileName.CreateL( finder.File() );

        }

    iEngine = CFMRadioActiveIdleEngine::NewL( *this );

    iEngine->ActivateL();

    FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::ConstructL - Exiting." )));    

    }

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

// Initialize resource file for loading resources.

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

//

void CFMRadioMCPPlugin::InitializeResourceLoadingL()

    {

    CCoeEnv* coeEnv = CCoeEnv::Static();

    RFs fs( coeEnv->FsSession() );

    TFileName fileName; 

    TFileName baseResource;

    TFindFile finder( fs );

    TLanguage language( ELangNone );

    TParsePtrC parse( KFMRadioMCPPluginResourceFileName );

    _LIT( resourceFileWildExt, ".r*" );

    // Make sure to find all resource files, not only .rsc files as it may be so

    // that there is only .r01, .r02, etc. files available

    fileName.Copy( parse.Name() );

    fileName.Append( resourceFileWildExt );

    // TFindFile applies search order that is from 

    // drive Y to A, then Z

    CDir* entries = NULL;

    TInt err = finder.FindWildByDir( fileName , KDC_RESOURCE_FILES_DIR, entries );

    delete entries;

    entries = NULL;

    TBool found = EFalse;

    while ( !found && err == KErrNone )

        {

        // Found file

        fileName.Zero();

        TParsePtrC foundPath( finder.File() );

        fileName.Copy( foundPath.DriveAndPath() );

        fileName.Append( KFMRadioMCPPluginResourceFileName );

        BaflUtils::NearestLanguageFile( fs, fileName, language );

        if ( language != ELangNone && BaflUtils::FileExists( fs, fileName ) )

            {

            found = ETrue;

            iResourceOffset = coeEnv->AddResourceFileL( fileName );

            }

        else

            {

            if ( language == ELangNone &&

                 !baseResource.Compare( KNullDesC ) &&

                 BaflUtils::FileExists( fs, fileName ) )

                {

                baseResource.Copy( fileName );

                }

            err = finder.FindWild( entries );

            delete entries;

            entries = NULL;

            }

        }

    if ( !found && baseResource.Compare( KNullDesC ) )

        {

        // If we found *.rsc then better to use that than nothing

        if ( BaflUtils::FileExists( fs, baseResource ) )

            {

            iResourceOffset = coeEnv->AddResourceFileL( baseResource );

            found = ETrue;

            }

        }

    if( !found )

        {

        User::Leave( KErrNotFound );

        }

    }

void CFMRadioMCPPlugin::Deactivate()

    {

    iActive = EFalse;

    }

void CFMRadioMCPPlugin::ActivateL()

    {

    FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::ActivateL()" )));

    iActive = ETrue;

    iObserver->BecameActiveL( this );

    iObserver->PublishTextL( this, EMusicWidgetDefaultText, KNullDesC );

    iObserver->PublishImageL( this, EMusicWidgetImage1,

                    KAknsIIDQgnIndiRadioDefault,

                    iMifFileName,

                    EMbmFmradioQgn_indi_radio_default,

                    EMbmFmradioQgn_indi_radio_default_mask );

    InstallFMRadioCommandActionL( KFMRadioCommandValueStartNowPlaying, EMusicWidgetTrigger1 );

    HandleChannelChangeL( iEngine->Channel() );

    }

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

// CFMRadioMCPPlugin::UpdatePublishedToolBarL

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

//

void CFMRadioMCPPlugin::UpdatePublishedToolBarL( TUint aToolBarState )

    {

    FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdatePublishedToolBarL - Entering." ))); 

    if ( iActive )

        {

        TAknsItemID iconId;

        if ( KFMRadioPrevious & aToolBarState )

            {

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdatePublishedToolBarL - 1 Enter" ))); 

            iconId.Set( EAknsMajorGeneric, EAknsMinorGenericQgnPropImageTbPrev );

            iObserver->PublishImageL( this, 

                                      EMusicWidgetToolbarB1, 

                                      iconId, 

                                      iMifFileName, 

                                      EMbmFmradioQgn_prop_image_tb_prev, 

                                      EMbmFmradioQgn_prop_image_tb_prev_mask );

            InstallFMRadioCommandActionL( KFMRadioCommandValueStepPrevious, EMusicWidgetTB1Trigger );

            iTbPreviousState = KFMRadioPrevious;

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdatePublishedToolBarL - 1 Exit" ))); 

            }

        if ( KFMRadioPreviousDimmed & aToolBarState )

            {

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdatePublishedToolBarL - 2 Enter" )));

            iconId.Set( EAknsMajorGeneric, EAknsMinorGenericQgnPropImageTbPrevDimmed ); 

            iObserver->PublishImageL( this, 

                                      EMusicWidgetToolbarB1, 

                                      iconId,

                                      iMifFileName, 

                                      EMbmFmradioQgn_prop_image_tb_prev_dimmed, 

                                      EMbmFmradioQgn_prop_image_tb_prev_dimmed_mask );

            InstallEmptyActionL( EMusicWidgetTB1Trigger );

            iTbPreviousState = KFMRadioPreviousDimmed; 

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdatePublishedToolBarL - 2 Exit" ))); 

            }

        if ( KFMRadioNext & aToolBarState )

            {

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdatePublishedToolBarL - 3 Enter" ))); 

            iconId.Set( EAknsMajorGeneric, EAknsMinorGenericQgnPropImageTbNext );

            iObserver->PublishImageL( this, 

                                      EMusicWidgetToolbarB3, 

                                      iconId, 

                                      iMifFileName, 

                                      EMbmFmradioQgn_prop_image_tb_next, 

                                      EMbmFmradioQgn_prop_image_tb_next_mask );

            InstallFMRadioCommandActionL( KFMRadioCommandValueStepNext, EMusicWidgetTB3Trigger );

            iTbNextState = KFMRadioNext;

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdatePublishedToolBarL - 3 Exit" ))); 

            }

        if ( KFMRadioNextDimmed & aToolBarState )

            {

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdatePublishedToolBarL - 4 Enter" ))); 

            iconId.Set( EAknsMajorGeneric, EAknsMinorGenericQgnPropImageTbNextDimmed );

            iObserver->PublishImageL( this, 

                                      EMusicWidgetToolbarB3, 

                                      iconId, 

                                      iMifFileName, 

                                      EMbmFmradioQgn_prop_image_tb_next_dimmed, 

                                      EMbmFmradioQgn_prop_image_tb_next_dimmed_mask );

            InstallEmptyActionL( EMusicWidgetTB3Trigger );

            iTbNextState = KFMRadioNextDimmed;            

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdatePublishedToolBarL - 4 Exit" ))); 

            }

        if ( KFMRadioMute & aToolBarState )

            {

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdatePublishedToolBarL - 5 Enter" ))); 

            iconId.Set( EAknsMajorGeneric, EAknsMinorGenericQgnIndiMusicWidgetTbRadioSound );

            iObserver->PublishImageL( this, 

                                      EMusicWidgetToolbarB2, 

                                      iconId, 

                                      iMifFileName, 

                                      EMbmFmradioQgn_indi_music_widget_tb_radio_sound, 

                                      EMbmFmradioQgn_indi_music_widget_tb_radio_sound_mask );

            InstallFMRadioCommandActionL( KFMRadioCommandValueUnmute, EMusicWidgetTB2Trigger );

            iTbMuteUnmuteState = KFMRadioMute;

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdatePublishedToolBarL - 5 Exit" ))); 

            }

        if ( KFMRadioUnmute & aToolBarState )

            {

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdatePublishedToolBarL - 6 Enter" ))); 

            iconId.Set( EAknsMajorGeneric, EAknsMinorGenericQgnIndiMusicWidgetTbRadioSoundMuted );

            iObserver->PublishImageL( this,

                                      EMusicWidgetToolbarB2,

                                      iconId,

                                      iMifFileName,

                                      EMbmFmradioQgn_indi_music_widget_tb_radio_sound_muted,

                                      EMbmFmradioQgn_indi_music_widget_tb_radio_sound_muted_mask );

            InstallFMRadioCommandActionL( KFMRadioCommandValueMute, EMusicWidgetTB2Trigger );

            iTbMuteUnmuteState = KFMRadioUnmute;            

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdatePublishedToolBarL - 6 Exit" ))); 

            }

        if ( KFMRadioMuteDimmed & aToolBarState )

            {

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdatePublishedToolBarL - 7 Enter" ))); 

            iconId.Set( EAknsMajorGeneric, EAknsMinorGenericQgnIndiMusicWidgetTbRadioSoundDimmed );

            iObserver->PublishImageL( this, 

                                      EMusicWidgetToolbarB2, 

                                      iconId, 

                                      iMifFileName, 

                                      EMbmFmradioQgn_indi_music_widget_tb_radio_sound_dimmed, 

                                      EMbmFmradioQgn_indi_music_widget_tb_radio_sound_dimmed_mask );

            InstallEmptyActionL( EMusicWidgetTB2Trigger );

            iTbMuteUnmuteState = KFMRadioMuteDimmed; 

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdatePublishedToolBarL - 7 Exit" ))); 

            }

        if ( KFMRadioUnmuteDimmed & aToolBarState )

            {

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdatePublishedToolBarL - 8 Enter" ))); 

            iconId.Set( EAknsMajorGeneric, EAknsMinorGenericQgnIndiMusicWidgetTbRadioSoundMutedDimmed );

            iObserver->PublishImageL( this, 

                                      EMusicWidgetToolbarB2, 

                                      iconId, 

                                      iMifFileName, 

                                      EMbmFmradioQgn_indi_music_widget_tb_radio_sound_muted_dimmed, 

                                      EMbmFmradioQgn_indi_music_widget_tb_radio_sound_muted_dimmed_mask );

            InstallEmptyActionL( EMusicWidgetTB2Trigger );

            iTbMuteUnmuteState = KFMRadioUnmuteDimmed;

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdatePublishedToolBarL - 8 Exit" ))); 

            }

        }

    }

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

// CFMRadioMCPPlugin::UpdateToolBarL

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

//

void CFMRadioMCPPlugin::UpdateToolBarL( TBool aForceApplicationClosing )

    {

    if ( iActive )

        {

        TUint muteDimmedState = iEngine->MuteState() == EFMRadioPSMuteStateOn ?

                KFMRadioUnmuteDimmed : KFMRadioMuteDimmed;

        // Update Next and Previous buttons.

        if ( iEngine->AntennaStatus() == EFMRadioPSHeadsetDisconnected )

            {

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdateToolBarL - 1" )));

            UpdatePublishedToolBarL( KFMRadioPreviousDimmed | muteDimmedState |  KFMRadioNextDimmed);

            return;

            }

        else if ( iEngine->ApplicationRunningState() != EFMRadioPSApplicationRunning || aForceApplicationClosing )

            {

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdateToolBarL - 2" )));

            UpdatePublishedToolBarL( KFMRadioPreviousDimmed | muteDimmedState |  KFMRadioNextDimmed);

            return;

            }

        else if ( iEngine->PowerState() != EFMRadioPSRadioPowerOn )

            {

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdateToolBarL - 3" )));

            UpdatePublishedToolBarL( KFMRadioPreviousDimmed | muteDimmedState |  KFMRadioNextDimmed);

            return;

            }

        else if ( iEngine->TuningState() != EFMRadioPSTuningUninitialized )

            {

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdateToolBarL - 4" )));

            UpdatePublishedToolBarL( KFMRadioPreviousDimmed |  KFMRadioNextDimmed );

            }

        else if ( iPresetCount > 1 || ( iPresetCount == 1 && iEngine->Channel() == KErrNotFound ) )

            {

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdateToolBarL - 5" )));

            UpdatePublishedToolBarL( KFMRadioPrevious | KFMRadioNext );

            }

        else

            {

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdateToolBarL - 6" )));

            UpdatePublishedToolBarL( KFMRadioPreviousDimmed | KFMRadioNextDimmed );

            }

        // Update Mute/Unmute button

        if ( iEngine->ApplicationRunningState() != EFMRadioPSApplicationRunning || aForceApplicationClosing )

            {

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdateToolBarL - 7" )));

            UpdatePublishedToolBarL( muteDimmedState );

            }

        else if ( iEngine->TuningState() != EFMRadioPSTuningUninitialized )

            {

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdateToolBarL - 8" )));

            UpdatePublishedToolBarL( muteDimmedState );

            }

        else

            {

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdateToolBarL - 9" )));

            HandleMuteStateChangeL( iEngine->MuteState() );

            }

        }

    }

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

// CFMRadioMCPPlugin::UpdateMusicWidgetTextL

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

//

void CFMRadioMCPPlugin::UpdateMusicWidgetTextL( TBool aForceApplicationClosing )

    {

    FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdateMusicWidgetTextL" )));

    if ( iActive )

        {

        TInt rightToLeftCharWidth = AknLayoutUtils::LayoutMirrored() ? sizeof(TText16) : 0;

        // Homescreen publishing

        if ( iEngine->AntennaStatus() == EFMRadioPSHeadsetDisconnected && !aForceApplicationClosing )

            {

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdateMusicWidgetTextL - Publishing HS antenna not connected: \"%S\""), &iAntennaNotConnectedText ));        

            iObserver->PublishTextL( this, EMusicWidgetText1, iAntennaNotConnectedText );

            }

        else if ( iEngine->TuningState() != EFMRadioPSTuningUninitialized && !aForceApplicationClosing )

            {

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdateMusicWidgetTextL - Publishing HS tuning: \"%S\""), &iTuningText ));        

            iObserver->PublishTextL( this, EMusicWidgetText1, iTuningText );

            }

        else if ( iPresetCount && iEngine->Channel() != KErrNotFound )

            {

            if( iEngine->ChannelName().Length() )

                {

                // Station saved and name is available

                RBuf name;

                // For widget

                // Preserve space for the channel name, format string and maximum index number

                name.CreateL( iEngine->ChannelName().Length() + 

                              iSavedStationFormat.Length() + 

                              KDefaultRealWidth + 

                              rightToLeftCharWidth );

                name.CleanupClosePushL();

                StringLoader::Format( name, iSavedStationFormat, KErrNotFound, iEngine->Channel() + 1 );

                HBufC* tempName = name.AllocL();

                StringLoader::Format( name, *tempName, KErrNotFound, iEngine->ChannelName() );

                delete tempName;

                tempName = NULL;

                if ( rightToLeftCharWidth )

                    {

                    //E.g. 1. Name -> Name .1

                    name.Insert( 0, KRightToLeftMark );

                    }

                FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdateMusicWidgetTextL - Publishing Music Widget saved station: \"%S\""), &name ));

                iObserver->PublishTextL( this, EMusicWidgetText1, name );

                CleanupStack::PopAndDestroy(); // name

                }

            else

                {

                // Station saved, but name for it is not available

                HBufC* frequencyString = FrequencyStringLC( iEngine->Frequency() );

                RBuf formattedFrequency;

                // For widget

                formattedFrequency.CreateL( iSavedStationFormatNoName.Length() + 

                                            frequencyString->Length() + 

                                            KDefaultRealWidth + 

                                            rightToLeftCharWidth );

                formattedFrequency.CleanupClosePushL();

                StringLoader::Format( formattedFrequency, iSavedStationFormatNoName, KErrNotFound, iEngine->Channel() + 1 );

                HBufC* tempFrequency = formattedFrequency.AllocL();

                StringLoader::Format( formattedFrequency, *tempFrequency, KErrNotFound, *frequencyString );

                delete tempFrequency;

                tempFrequency = NULL;

                AknTextUtils::LanguageSpecificNumberConversion( formattedFrequency );

                if ( rightToLeftCharWidth )

                    {

                    //E.g. 1. Name -> Name .1

                    formattedFrequency.Insert( 0, KRightToLeftMark );

                    }

                FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdateMusicWidgetTextL - Publishing Music Widget saved station with frequency: \"%S\""), &formattedFrequency ));

                iObserver->PublishTextL( this, EMusicWidgetText1, formattedFrequency );

                CleanupStack::PopAndDestroy( 2 ); // formattedFrequency, frequencyString

                }

            }

        else if ( iEngine->RDSProgramService().Length() > 0 )

            {

            FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdateMusicWidgetTextL - Publishing HS PS name: \"%S\""), &iEngine->RDSProgramService() ));

            iObserver->PublishTextL( this, EMusicWidgetText1, iEngine->RDSProgramService() );

            }

        else

            {

            TInt currentFrequency = iEngine->Frequency();

            // publish only valid frequency

            if ( currentFrequency > 0 )

                {

                HBufC* frequencyString = FrequencyStringLC( currentFrequency );

                RBuf formattedFrequency;

                // For widget

                // Preserve space for the format string and maximum index number

                formattedFrequency.CreateL( iFrequencyFormat.Length() + 

                                            frequencyString->Length() + 

                                            rightToLeftCharWidth );

                formattedFrequency.CleanupClosePushL();

                StringLoader::Format( formattedFrequency, iFrequencyFormat, KErrNotFound, *frequencyString );

                AknTextUtils::LanguageSpecificNumberConversion( formattedFrequency );

                if ( rightToLeftCharWidth )

                    {

                    //E.g. 1. Name -> Name .1

                    formattedFrequency.Insert( 0, KRightToLeftMark );

                    }

                FTRACE(FPrint(_L(" *** S60 FMRadio -- CFMRadioMCPPlugin::UpdateMusicWidgetTextL - Publishing Music Widget frequency: \"%S\""), &formattedFrequency ));

                iObserver->PublishTextL( this, EMusicWidgetText1, formattedFrequency );

                CleanupStack::PopAndDestroy( 2 ); // formattedFrequency,frequencyString