/*

* Copyright (c) 2005 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:  Contains implementation of the CCentralRepositoryHandler class.

*

*/

//  INCLUDE FILES

#include <centralrepository.h>

#include <s32mem.h>

#include <coemain.h> 

#include <barsread.h>

#include <ProfileEngineSDKCRKeys.h>

#include <fmradioengine.rsg>

#include "fmradioenginecentralrepositoryhandler.h"

#include "fmradioengineradiosettings.h"

#include "fmradioenginecrkeys.h"

#include "debug.h"

// CONSTANTS

const TInt KRadioMaxStartupCountToTrack = 5;

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

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

// CCentralRepositoryHandler::CCentralRepositoryHandler

// Default class constructor.

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

//

CCentralRepositoryHandler::CCentralRepositoryHandler(

    TRadioSettings& aRadioSettings)  // a reference to aRadioSettings

    :iRadioSettings(&aRadioSettings)

    {

    FTRACE(FPrint(_L("calling CCentralRepositoryHandler::NewL()")));

    }

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

// CCentralRepositoryHandler::ConstructL

// Second phase class constructor.

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

//

void CCentralRepositoryHandler::ConstructL()

    {

    iCentralRepository = CRepository::NewL( KCRUidFMRadioEngine );

    RetrieveInitialSettings();                

    InitializeRegionsL();

    #ifdef __WINS__

    SetInitialSettings();

    #endif //__WINS__    

    }

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

// CCentralRepositoryHandler::NewL

// Two-phased class constructor.

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

//

CCentralRepositoryHandler* CCentralRepositoryHandler::NewL(

    TRadioSettings& aRadioSettings)  // a reference to aRadioSettings

    {

    CCentralRepositoryHandler *self = new(ELeave) CCentralRepositoryHandler(aRadioSettings);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CCentralRepositoryHandler::~CCentralRepositoryHandler

// Destructor of CCentralRepositoryHandler class.

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

//

CCentralRepositoryHandler::~CCentralRepositoryHandler()

    {

    iRadioSettings = NULL;

    if ( iCentralRepository )

         {

         delete iCentralRepository;

         }

	iRegions.ResetAndDestroy();

	iRegions.Close();                

    }

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

// CCentralRepositoryHandler::RetrieveInitialSettings

// Retrieves persistent settings from shared data.

// Returns: None

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

//

void CCentralRepositoryHandler::RetrieveInitialSettings()

    {

    FTRACE(FPrint(_L("calling CCentralRepositoryHandler::RetrieveInitialSettings() Start")));

    TInt tempData;

    if ( iCentralRepository->Get( KRadioHeadsetVolume, tempData ) == KErrNone )

          {

          iRadioSettings->SetHeadsetVolume( tempData );

          }

    if ( iCentralRepository->Get( KRadioSpeakerVolume, tempData ) == KErrNone ) 

            {

            iRadioSettings->SetSpeakerVolume( tempData );

            }

    if ( iCentralRepository->Get( KFmRadioFrequency, tempData ) == KErrNone )

        {

        iRadioSettings->SetFrequency( tempData );

        }

    if ( iCentralRepository->Get( KFmRadioChannel, tempData ) == KErrNone )

        {

        iRadioSettings->SetCurrentPreset( tempData );

        }

    if ( iCentralRepository->Get( KFmRadioMode, tempData ) == KErrNone)

        {

        iRadioSettings->SetRadioMode( static_cast<CRadioEngine::TRadioMode>( tempData ) );        

        }

	if ( iCentralRepository->Get( KFMCRCurrentRegion, tempData ) != KErrNone )	        

		{

		iCentralRepository->Set( KFMCRCurrentRegion, KErrNotFound );			

		}

	if ( iCentralRepository->Get( KRadioCRStartupCount, tempData ) == KErrNone )

		{

		iRadioSettings->SetStartupCount( tempData );

		}

	if ( iCentralRepository->Get( KFMCRRdsAfSearchEnabled, tempData ) == KErrNone )

        {

        if ( static_cast<TBool> ( tempData ) )

        	{

        	iRadioSettings->SetRdsAfSearchEnabled();

        	}

        else

        	{

            iRadioSettings->SetRdsAfSearchDisabled();

        	}

        }

	if ( iCentralRepository->Get( KFMCRJapanRegionAllowed, tempData ) == KErrNone )

		{				

		iRadioSettings->SetJapanRegionAllowed( static_cast<TBool>( tempData ) );

		}			       	        

    }

#ifdef __WINS__

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

// CCentralRepositoryHandler::SetInitialSettings

// Set network info for emulator testing purposes

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

//

void CCentralRepositoryHandler::SetInitialSettings()

	{

	_LIT(KNetworkInfoForEmulator, "358123");

	iCentralRepository->Set( KFMRadioCREmulatorNetworkInfo, KNetworkInfoForEmulator );			

	}

#endif //__WINS__	

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

// CCentralRepositoryHandler::SaveEngineSettings

// Save all engine related persistent info back to shared data

// Returns: None

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

//

void CCentralRepositoryHandler::SaveEngineSettings()

    {

    if ( IsFrequencyValid( iRadioSettings->Frequency() / KFMRadioFreqMultiplier ) )

    	{

    	iCentralRepository->Set( KFmRadioFrequency, iRadioSettings->Frequency() );

    	}

    else

    	{

    	TInt freq = MinFrequency() * KFMRadioFreqMultiplier;

    	iCentralRepository->Set( KFmRadioFrequency, freq  );

    	}

    iCentralRepository->Set( KFmRadioChannel, iRadioSettings->CurrentPreset() );

    iCentralRepository->Set( KFmRadioMode, iRadioSettings->RadioMode() );

    iCentralRepository->Set( KFMCRRdsAfSearchEnabled, iRadioSettings->IsRdsAfSearchEnabled() );

    }

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

// CCentralRepositoryHandler::CountRegions

// Return count of fmradio regions in regions array

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

//

TInt CCentralRepositoryHandler::CountRegions() const

    {

    return iRegions.Count();

    }

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

// CCentralRepositoryHandler::Region

// Returns fmradio region at given index

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

//

CFMRadioRegion& CCentralRepositoryHandler::Region( TInt aIndex ) const

    {    

    if( aIndex == KErrNotFound )

        {

        aIndex = RegionIndexForId( static_cast<TInt>( EFMRadioRegionDefault ) );        

        }

    return *iRegions[aIndex];

    }

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

// CCentralRepositoryHandler::RegionId

// Return current region Id.

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

//

TInt CCentralRepositoryHandler::RegionId() const

    {

    TInt regionId;

    iCentralRepository->Get( KFMCRCurrentRegion, regionId );

    return regionId;

    }

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

// CCentralRepositoryHandler::SetRegionIdL

// Change the the current region Id.

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

//

void CCentralRepositoryHandler::SetRegionIdL( TInt aRegion )

    {

    iCentralRepository->Set( KFMCRCurrentRegion, aRegion );

    UpdateCurrentRegionIdx( aRegion );    

    iRadioSettings->SetFrequency( Region( iCurrentRegionIdx ).MinFrequency() * KFMRadioFreqMultiplier ); 

	iRadioSettings->SetMinFrequency( MinFrequency() );

	iRadioSettings->SetMaxFrequency( MaxFrequency() );

	iRadioSettings->SetFrequencyStepSize( FrequencyStepSize() );

	iRadioSettings->SetDecimalCount( DecimalCount() );

    }

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

// CCentralRepositoryHandler::FrequencyStepSize

// Returns frequency step size used for current region

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

//

TUint32 CCentralRepositoryHandler::FrequencyStepSize() const

    {

    return Region( iCurrentRegionIdx ).StepSize();

    }

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

// CCentralRepositoryHandler::MaxFrequency

// Returns highest allowed frequency for current region

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

//

TUint32 CCentralRepositoryHandler::MaxFrequency() const

    {

    return Region( iCurrentRegionIdx ).MaxFrequency();

    }

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

// CCentralRepositoryHandler::MinFrequency

// Returns lowest allowed frequency for current region

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

//

TUint32 CCentralRepositoryHandler::MinFrequency() const

    {

    return Region( iCurrentRegionIdx ).MinFrequency();

    }

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

// CCentralRepositoryHandler::DecimalCount

// return decimal count for current region Mhz information

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

//

TInt CCentralRepositoryHandler::DecimalCount() const

    {

    return Region( iCurrentRegionIdx ).DecimalCount();

    }

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

// CCentralRepositoryHandler::InitializeRegionsL

// Initializes the regions based on resources.

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

//

void CCentralRepositoryHandler::InitializeRegionsL()

    {

	iRegions.ResetAndDestroy();

	TResourceReader reader;

	CCoeEnv* coeEnv = CCoeEnv::Static();

	if ( iRadioSettings->IsJapanRegionAllowed() )

		{

		coeEnv->CreateResourceReaderLC( reader, R_RADIO_REGIONS_ALL );	

		}

	else // Japan region is not allowed so read region resources without Japan

		{

		coeEnv->CreateResourceReaderLC( reader, R_RADIO_REGIONS_WITHOUT_JAPAN );					

		}

	TInt regionCount = reader.ReadInt16();

	for( TInt i = 0 ; i < regionCount; i++ )

		{

		TInt resId = reader.ReadInt32(); // The next resource ID to read.

        TResourceReader regionReader;

        coeEnv->CreateResourceReaderLC( regionReader, resId );

		User::LeaveIfError( iRegions.Append( CFMRadioRegion::NewL( regionReader ) ) );

		CleanupStack::PopAndDestroy();

		}

	CleanupStack::PopAndDestroy();

    UpdateCurrentRegionIdx( RegionId() );

	iRadioSettings->SetMinFrequency( MinFrequency() * KFMRadioFreqMultiplier );

	iRadioSettings->SetMaxFrequency( MaxFrequency() * KFMRadioFreqMultiplier );

	iRadioSettings->SetFrequencyStepSize( FrequencyStepSize() );

	iRadioSettings->SetDecimalCount( DecimalCount() );

    }

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

// CCentralRepositoryHandler::RegionIndexForId

// Converts Region ID to index

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

//

TInt CCentralRepositoryHandler::RegionIndexForId( TInt aRegionId ) const

    {

    TInt idx = KErrNotFound;

    for( TInt i = 0 ; i < CountRegions(); i++ )

        {

        if( Region( i ).Id() == static_cast<TFMRadioRegionSetting>( aRegionId ) )

            {

            idx = i;

            /*lint -save -e960 (Note -- Violates MISRA Required Rule 58, non-switch break used)*/

            break;

            /*lint -restore*/

            }

        }

    return idx;

    }

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

// CCentralRepositoryHandler::UpdateCurrentRegionIdx

// Updates the current region

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

//

void CCentralRepositoryHandler::UpdateCurrentRegionIdx( TInt aRegionId )

    {

    iCurrentRegionIdx = RegionIndexForId( aRegionId );

    }

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

// CCentralRepositoryHandler::IsOfflineProfileActiveL

// Checks if offine profile is current active profile

// Returns: true/false 

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

//    

TBool CCentralRepositoryHandler::IsOfflineProfileActiveL()

	{

	CRepository* repository = CRepository::NewLC( KCRUidProfileEngine );

	TInt profileId(0);

	// Get ID of current profile

	User::LeaveIfError( repository->Get( KProEngActiveProfile, profileId ) );

	CleanupStack::PopAndDestroy( repository );

	// Check value to determine the active profile

	// 5 = Offline profile

	if ( profileId == 5 )

		{

		// Current profile is the offline profile

		return ETrue;

		}

	return EFalse;	

	}

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

// CCentralRepositoryHandler::IsFrequencyValid

// Checks if frequency is in the current region range

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

//

TBool CCentralRepositoryHandler::IsFrequencyValid( TUint32 aFrequency ) const

    {

    TBool ret( EFalse );

    if( !aFrequency )

        {

        aFrequency = iRadioSettings->Frequency();

        }

    if ( aFrequency >= MinFrequency() && aFrequency <= MaxFrequency() )

        {

        ret = ETrue;

        }

    return ret;

    }

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

// CCentralRepositoryHandler::IncreaseStartupCount

// Increases startup time by one and sets the value to the repository

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

//    

void CCentralRepositoryHandler::IncreaseStartupCount() const

	{				

	TInt startCount = iRadioSettings->StartupCount();

	// Dont update if maximum tracking count is reached

	if ( startCount < KRadioMaxStartupCountToTrack )

		{

		startCount++;

		iRadioSettings->SetStartupCount( startCount ); 

		iCentralRepository->Set( KRadioCRStartupCount, startCount );	

		}	

	}

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

// CCentralRepositoryHandler::SaveHeadsetVolumeSetting

// Save headset volume level to the repository

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

//	

void CCentralRepositoryHandler::SaveHeadsetVolumeSetting() const

	{

	FTRACE( FPrint(_L("CCentralRepositoryHandler::SaveHeadsetVolumeSetting()") ) );

	iCentralRepository->Set( KRadioHeadsetVolume, iRadioSettings->HeadsetVolume() );	

	}

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

// CCentralRepositoryHandler::SaveSpeakerVolumeSetting

// Save speaker volume level to the repository

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

//	

void CCentralRepositoryHandler::SaveSpeakerVolumeSetting() const

	{

	FTRACE( FPrint(_L("CCentralRepositoryHandler::SaveSpeakerVolumeSetting()") ) );

	iCentralRepository->Set( KRadioSpeakerVolume, iRadioSettings->SpeakerVolume() );		

	}

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

// CCentralRepositoryHandler::MusicStoreNoteDisplayed

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

//

TBool CCentralRepositoryHandler::MusicStoreNoteDisplayed()

    {

    TBool result;

    TInt err = iCentralRepository->Get( KRadioMusicStoreNoteDisplayed, result );

    if ( err != KErrNone )

    	{

    	result = EFalse;

    	}    

    return result;

    }

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

// CCentralRepositoryHandler::SetMusicStoreNoteDisplayed

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

//

void CCentralRepositoryHandler::SetMusicStoreNoteDisplayed()

    {

    iCentralRepository->Set( KRadioMusicStoreNoteDisplayed, 1 );

    }

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

// CCentralRepositoryHandler::GetRTPlusSupportLevel

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

//

TInt CCentralRepositoryHandler::GetRTPlusSupportLevel()

    {

    //See fmradioengine.hrh:TFMRadioRTPlusLevel for correct values

    TInt result;

    TInt err = iCentralRepository->Get( KRadioRTPlusSupportLevel, result );

    if ( err != KErrNone )

    	{

    	result = KErrNotFound;

    	}

    return result;

    }

// end of file