/*
* Copyright (c) 2006-2007 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: ?Description
*
*/
#include "pspresetnotifier.h"
#include "pstransaction.h"
#include "irdebug.h"
#include "irfavoritesdb.h"
#include "irisdspreset.h"
#include "irpreset.h"
#include "irsettings.h"
const TInt KNullId = 0;
const TInt KNineteen = 19;
namespace PresetHandler
{
//-------------------------------------------------------------------------------
//TInt OrderByIndex( const CIRPresetImpl& aPreset1, const CIRPresetImpl& aPreset2 )
//-------------------------------------------------------------------------------
//
//Sort algorithm
// Orders presets by their index.
//
TInt OrderByIndex( const CIRPreset& aPreset1, const CIRPreset& aPreset2 )
{
if ( aPreset1.Index() < aPreset2.Index() )
{
return -1;
}
else if ( aPreset1.Index() > aPreset2.Index() )
{
return 1;
}
else
{
return 0;
}
}
TInt OrderByPlayedTimes(const CIRPreset& aPreset1, const CIRPreset& aPreset2)
{
int difference = aPreset1.GetPlayedTimes() - aPreset2.GetPlayedTimes();
if (difference > 0)
{
return -1;
}
else if (difference == 0)
{
return aPreset1.Name().Compare(aPreset2.Name());
}
else
{
return 1;
}
}
}
//---------------------------------------------------------------------------
//CIRFavoritesDb::NewL()
//standard symbian 1st phase constructor
//---------------------------------------------------------------------------
//
EXPORT_C CIRFavoritesDb* CIRFavoritesDb::NewL()
{
IRLOG_DEBUG( "CIRFavoritesDb::NewL" );
CIRFavoritesDb* self = new ( ELeave ) CIRFavoritesDb;
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
IRLOG_DEBUG( "CIRFavoritesDb::NewL - Exiting." );
return self;
}
//---------------------------------------------------------------------------
//CIRFavoritesDb::~CIRFavoritesDb()
//standard c++ destructor
//---------------------------------------------------------------------------
//
CIRFavoritesDb::~CIRFavoritesDb()
{
IRLOG_DEBUG( "CIRFavoritesDb::~CIRFavoritesDb" );
delete iNotifier;
iObservers.Close();
//resets the preset array
iFavPresetList.ResetAndDestroy();
iFavPresetList.Close();
iServ.Close();
IRLOG_DEBUG( "CIRFavoritesDb::~CIRFavoritesDb - Exiting." );
}
//---------------------------------------------------------------------------
//CIRFavoritesDb::AddPresetL()
//exported function to add a preset
//---------------------------------------------------------------------------
//
EXPORT_C void CIRFavoritesDb::AddPresetL(CIRIsdsPreset& aPreset,
TInt& aRetVal, TBool /*aIsLogoAvialable*/)
{
IRLOG_DEBUG( "CIRFavoritesDb::AddPresetL" );
iMoveStatus=EFalse;
SortByIndex() ;//sorted by index
TBool presetSaved = EFalse;
// Check the existence of preset before checking if the list is full
// to avoid KErrNoMemory for a preset that exists in the list.
TInt searchResult = 0;
if (aPreset.GetChannelType() == 0)
{
searchResult = SearchUserDefinedPreset(aPreset.GetName(), aPreset.GetChannelUrlAtL(0));
//we don't allow user to add presets with the same name
if (searchResult >= 0)
{
ReplaceUserDefinedPresetL(aPreset);
aRetVal = KErrAlreadyExists;
return;
}
}
else
{
searchResult = SearchPreset( aPreset.GetId(), KNullId );
if( KErrNotFound != searchResult)
{
//Eventhough the preset exists in the favorites db, replace the
//same with the new preset i.e. aPreset. Because the db should
//contain the updated values of the preset.
ReplacePresetL(aPreset);
aRetVal = KErrAlreadyExists;
return;
}
}
if ( EmptyPresetCount()<=0 )
{
//max limit reached no more processing
aRetVal = KErrNoMemory;
return;
}
// Found the next empty place or replace
for ( TInt j=0; j < MaxPresetCount() && !presetSaved; j++ )
{
CIRPreset* preset = PresetByIndex( j );
TBool presetExisted = preset ? ETrue : EFalse;//presetExisted=1 if preset exists
if ( !preset )
{
preset = CreatePresetL( j );//create if preset==NULL
}
if ( !presetExisted )//crete if preset did not exists
{
//open a transaction with the preset server
CPSTransaction* transaction = preset->CreateTransactionLC();
//Convert to Plugnized Preset
//That is accepted by the preset server
preset->CIRIsdsPresetToCIRPresetImpl(aPreset);
//setname of CPSPresetInterface is called
preset->SetNameL( aPreset.GetName() );
transaction->CommitL();
CleanupStack::PopAndDestroy( transaction );
//added to check multiple insertion
presetSaved = ETrue;
}
}
aRetVal = KErrNone;
IRLOG_DEBUG( "CIRFavoritesDb::AddPresetL - Exiting." );
}
//---------------------------------------------------------------------------
//CIRFavoritesDb::AddPresetL()
//exported,overloaded function to add a preset manually
//converts the minimum data(name ,url) into an preset
//---------------------------------------------------------------------------
//
EXPORT_C void CIRFavoritesDb::AddPresetL(const TDesC& aName,
const TDesC& aURl,TInt& aReturn, TBool /*aIsLogoAvialable*/)
{
IRLOG_DEBUG( "CIRFavoritesDb::AddPresetL(des des int int)" );
iMoveStatus=EFalse;
CIRIsdsPreset* saveItem;
saveItem = CIRIsdsPreset::NewLC();
saveItem->SetName(aName);
saveItem->SetUrlCount(1);//only one url is saved for manually added channel
saveItem->SetChannelType(EUserDefined);
_LIT(KNotAvailable,"NA");
//bitrate set to zero so that it is accessible to all kinds of bitrate settings
saveItem->SetUrlL(KNotAvailable,aURl,0);
AddPresetL(*saveItem,aReturn);
CleanupStack::PopAndDestroy(saveItem);
IRLOG_DEBUG( "CIRFavoritesDb::AddPresetL(des des int int) - Exiting." );
}
//---------------------------------------------------------------------------
//CIRFavoritesDb::DeletePresetL()
//exported, function to delete a preset
//---------------------------------------------------------------------------
//
EXPORT_C void CIRFavoritesDb::DeletePresetL( TInt aId )
{
IRLOG_DEBUG( "CIRFavoritesDb::DeletePresetL" );
iMoveStatus=EFalse;
iServ.DeletePresetL( aId);
TInt count = iFavPresetList.Count();
//when we delete one preset in the server's db, we also
//need to delete it in the favorite list.
for( TInt i=0; i<count; i++ )
{
if( aId == iFavPresetList[i]->Id())
{
//before Remove, the memory should be freed ahead.
delete iFavPresetList[i];
iFavPresetList.Remove(i);
break;
}
}
IRLOG_DEBUG( "CIRFavoritesDb::DeletePresetL - Exiting." );
}
//---------------------------------------------------------------------------
//CIRFavoritesDb::GetAllPresetL()
//exported,function to get the list of saved presets in the array iFavPresetList
//---------------------------------------------------------------------------
//
EXPORT_C void CIRFavoritesDb::GetAllPreset()
{
IRLOG_DEBUG( "CIRFavoritesDb::GetAllPresetL" );
//sort the array according to the index values
SortByIndex();
IRLOG_DEBUG( "CIRFavoritesDb::GetAllPresetL - Exiting." );
}
/*
* get all presets sorted by played times
*/
EXPORT_C const RIRPresetArray& CIRFavoritesDb::GetAllSortedPresets()
{
iFavPresetList.Sort( TLinearOrder<CIRPreset>(PresetHandler::OrderByPlayedTimes));
return iFavPresetList;
}
//---------------------------------------------------------------------------
//CIRFavoritesDb::SwapPresetsInDbL()
//returns the previous preset for a given presetId
//---------------------------------------------------------------------------
//
EXPORT_C void CIRFavoritesDb::SwapPresetsInDbL( TInt aChannelIdFrom,
TInt /*aChannelIdTo*/,TInt /*aChannelIndexFro*/,TInt aChannelIndexTo )
{
IRLOG_DEBUG( "CIRFavoritesDb::SwapPresetsInDbL" );
MovePresetL( aChannelIdFrom,aChannelIndexTo);
IRLOG_DEBUG( "CIRFavoritesDb::SwapPresetsInDbL - Exiting." );
}
//---------------------------------------------------------------------------
//CIRFavoritesDb::MovePresetL()
//moves a preset to destination index
//---------------------------------------------------------------------------
//
void CIRFavoritesDb::MovePresetL( const TInt aId, const TInt aDestinationIndex )
{
IRLOG_DEBUG( "CIRFavoritesDb::MovePresetL" );
ASSERT( aDestinationIndex >= 0 && aDestinationIndex < iFavPresetList.Count() );
if( aDestinationIndex < 0 || aDestinationIndex >= iFavPresetList.Count())
{
User::Leave(KErrArgument);
}
TInt fakeIndex=iFavPresetList[aDestinationIndex]->Index();
SetMoveStatus(ETrue);
iServ.MovePresetL( aId, fakeIndex );
IRLOG_DEBUG( "CIRFavoritesDb::MovePresetL - Exiting." );
}
//---------------------------------------------------------------------------
//CIRFavoritesDb::SetMoveStatus()
//sets the status of Move functionality
//---------------------------------------------------------------------------
//
EXPORT_C void CIRFavoritesDb::SetMoveStatus(TBool aStatus)
{
iMoveStatus = aStatus;
}
//---------------------------------------------------------------------------
//CIRFavoritesDb::GetMoveStatus()
//returns the status of the Move functionality
//---------------------------------------------------------------------------
//
EXPORT_C TBool CIRFavoritesDb::GetMoveStatus()
{
return iMoveStatus;
}
//---------------------------------------------------------------------------
//CIRFavoritesDb::SearchPreset()
//exported, function to find out if a preset exists in the favorites list
//---------------------------------------------------------------------------
//
EXPORT_C TInt CIRFavoritesDb::SearchPreset( const TInt aIsdsPresetId,
const TInt aUniqPresetId)
{
IRLOG_DEBUG( "CIRFavoritesDb::SearchPreset" );
TInt count = iFavPresetList.Count();
TInt iter;
//for isds presets
if(aIsdsPresetId!=KNullId)
{
for(iter=0;iter<count;iter++)
{
if(iFavPresetList[iter]->GetId() == aIsdsPresetId)
{
IRLOG_DEBUG( "CIRFavoritesDb::SearchPreset - Exiting (1)." );
return iter;
}
}
}
if(aUniqPresetId != KNullId )
//for manually added presets
{
for(iter=0;iter<count;iter++)
{
if(aUniqPresetId==iFavPresetList[iter]->Id())
{
IRLOG_DEBUG( "CIRFavoritesDb::SearchPreset - Exiting (2)." );
return iter;
}
}
}
// both the parameters are null implies that the preset is a non saved station
IRLOG_DEBUG( "CIRFavoritesDb::SearchPreset - Exiting (3)." );
return KErrNotFound;
}
//---------------------------------------------------------------------------
//CIRFavoritesDb::GetPreviousPreset()
//exported, function to find out if a preset exists in the favorites list
//---------------------------------------------------------------------------
//
EXPORT_C TInt CIRFavoritesDb::GetNextPreset(TInt aIndex)
{
if ( (aIndex==(iFavPresetList.Count()-1))||aIndex==KNineteen )
{
return 0;
}
else
{
return aIndex+1;
}
}
//---------------------------------------------------------------------------
//CIRFavoritesDb::GetNextPreset()
//exported, function to find out if a preset exists in the favorites list
//---------------------------------------------------------------------------
//
EXPORT_C TInt CIRFavoritesDb::GetPreviousPreset( TInt aIndex )
{
if ( aIndex==0 )
{
TInt val=(iFavPresetList.Count()-1);
return val;
}
else
{
return aIndex-1;
}
}
//---------------------------------------------------------------------------
//CIRFavoritesDb::ReplacePresetL()
//replaces a preset with a new preset
//for presetSync
//---------------------------------------------------------------------------
//
EXPORT_C void CIRFavoritesDb::ReplacePresetL( CIRIsdsPreset& aNewPreset )
{
IRLOG_DEBUG( "CIRFavoritesDb::ReplacePresetL" );
iMoveStatus=EFalse;
CIRPreset* preset;
TInt index = SearchPreset(aNewPreset.GetId(),KNullId);
//actual index
if (index >= 0)
{
ASSERT( index >= 0 || index < iFavPresetList.Count() );
index = iFavPresetList[index]->Index();
preset = PresetByIndex(index);
if (preset)
{
CPSTransaction* transaction = preset->CreateTransactionLC();
//change the preset data and commit
//update 'name' only if this station has not been renamed before
if (preset->GetRenamed())
{
aNewPreset.SetName(preset->Name());
}
preset->CIRIsdsPresetToCIRPresetImpl(aNewPreset);
preset->SetChannelType(EIsdsPreset);
transaction->CommitL();
CleanupStack::PopAndDestroy( transaction );
}
}
IRLOG_DEBUG( "CIRFavoritesDb::ReplacePresetL - Exiting." );
}
//---------------------------------------------------------------------------
//CIRFavoritesDb::ReplaceUserDefinedPresetL()
//replaces a userdefined preset with a new userdefiend preset
//for presetSync
//---------------------------------------------------------------------------
//
EXPORT_C void CIRFavoritesDb::ReplaceUserDefinedPresetL(CIRIsdsPreset& aNewPreset)
{
IRLOG_DEBUG( "CIRFavoritesDb::ReplaceUserDefinedPresetL" );
iMoveStatus=EFalse;
TInt index = SearchUserDefinedPreset(aNewPreset.GetName(), aNewPreset.GetChannelUrlAtL(0));
if (index >= 0 && index < iFavPresetList.Count())
{
CIRPreset* preset = iFavPresetList[index];
if (preset)
{
CPSTransaction* transaction = preset->CreateTransactionLC();
/**
* change the preset data and commit
*/
preset->CIRIsdsPresetToCIRPresetImpl(aNewPreset);
preset->SetChannelType(EUserDefined);
preset->SetNameL(aNewPreset.GetName());
preset->SetDescription(aNewPreset.GetShortDescription());
transaction->CommitL();
CleanupStack::PopAndDestroy(transaction);
}
}
IRLOG_DEBUG( "CIRFavoritesDb::ReplaceUserDefinedPresetL - Exiting." );
}
//---------------------------------------------------------------------------
//IRFavoritesDb::MakePresetUserDefinedL()
//for a favorite preset that has been removed from the isds.
//it is made a user defined preset by changing the type to 0.
//index value is preseved so that the relative positions in the saved
//stations view remains the same.
//---------------------------------------------------------------------------
//
EXPORT_C void CIRFavoritesDb::MakePresetUserDefinedL( TInt aChannelId,
TInt /*aUserDefinedChannelId*/ )
{
IRLOG_DEBUG( "CIRFavoritesDb::MakePresetUserDefinedL" );
iMoveStatus=EFalse;
//to match the function signature
TInt index = SearchPreset(aChannelId,KNullId);
CIRPreset* preset;
//actual index
if (index >= 0)
{
ASSERT( index >= 0 || index < iFavPresetList.Count() );
index = iFavPresetList[index]->Index();
preset = PresetByIndex(index);
if(preset)
{
CPSTransaction* transaction = preset->CreateTransactionLC();
//convert the flag to user defined and commit
preset->SetChannelType(EUserDefined);
//assign null id
preset->SetId(KNullId);
//make logo as null;;;; added for 2.0
_LIT8(KEmpty, "");
RBuf8 tempLogo;
tempLogo.Create(KEmpty);
preset->SetLogoData(tempLogo);
tempLogo.Close();
_LIT(KEmptyString, "");
RBuf tempString;
tempString.Create(KEmptyString);
//set imgurl to null
preset->SetImgUrl(tempString);
//set genre to null
preset->SetGenreInfo(tempString,tempString);
//set language to null
preset->SetLang(tempString);
//set country to null
preset->SetCountryName(tempString);
tempString.Close();
//set musicStoreEnabled filed to "no";;;;added for 2.0
_LIT(KNo, "no");
RBuf tempMusicStoreEnabled;
tempMusicStoreEnabled.Create(KNo);
preset->SetMusicStoreStatus(tempMusicStoreEnabled);
tempMusicStoreEnabled.Close();
transaction->CommitL();
CleanupStack::PopAndDestroy( transaction );
}
}
IRLOG_DEBUG( "CIRFavoritesDb::MakePresetUserDefinedL - Exiting." );
}
//---------------------------------------------------------------------------
//const RVRPresetArray& CVRPresetHandler::Presets() const
// RIRPresetArray& an array containing all Internet Radio presets.
//---------------------------------------------------------------------------
//
EXPORT_C const RIRPresetArray& CIRFavoritesDb::Presets() const
{
IRLOG_DEBUG( "CIRFavoritesDb::Presets" );
//sort by
return iFavPresetList;
}
/*
* Increase the played times of a channel if it has been in the favorites
* return : KErrNone if success
* KErrNotFound if the preset is not in the favorites
*/
EXPORT_C TInt CIRFavoritesDb::IncreasePlayedTimesL(const CIRIsdsPreset &aIsdsPreset)
{
//step 1 : search the preset in favorites
SortByIndex();
TInt index = 0;
if (aIsdsPreset.GetChannelType() == 0)
{
index = SearchUserDefinedPreset(aIsdsPreset.GetName(), aIsdsPreset.GetChannelUrlAtL(0));
}
else
{
index = SearchPreset(aIsdsPreset.GetId(), KNullId);
}
if (KErrNotFound == index)
{
return KErrNotFound;
}
//step 2 : update the played times of the preset
CIRPreset *irPreset = iFavPresetList[index];
//open a transaction with the preset server
CPSTransaction* transaction = irPreset->CreateTransactionLC();
irPreset->SetPlayedTimes(irPreset->GetPlayedTimes() + 1);
transaction->CommitL();
CleanupStack::PopAndDestroy(transaction);
return KErrNone;
}
EXPORT_C TInt CIRFavoritesDb::RenamePresetL(const CIRIsdsPreset &aIsdsPreset, const TDesC &aNewName)
{
TInt index = 0;
if (aIsdsPreset.GetChannelType() == 0)
{
index = SearchUserDefinedPreset(aNewName, aIsdsPreset.GetChannelUrlAtL(0));
if (KErrNotFound != index)
{
//there is already a user-defined station with same name and url
return KErrAlreadyExists;
}
else
{
index = SearchUserDefinedPreset(aIsdsPreset.GetName(), aIsdsPreset.GetChannelUrlAtL(0));
}
}
else
{
index = SearchPreset(aIsdsPreset.GetId(), KNullId);
}
if (KErrNotFound == index)
{
return KErrNotFound;
}
CIRPreset *irPreset = iFavPresetList[index];
//open a transaction with the preset server
CPSTransaction* transaction = irPreset->CreateTransactionLC();
irPreset->SetNameL(aNewName);
irPreset->SetRenamed();
transaction->CommitL();
CleanupStack::PopAndDestroy(transaction);
return KErrNone;
}
//---------------------------------------------------------------------------
//CIRFavoritesDb::ConstructL()
//Standard 2nd phase construction
//---------------------------------------------------------------------------
//
void CIRFavoritesDb::ConstructL()
{
IRLOG_DEBUG( "CIRFavoritesDb::ConstructL" );
//cenrep handle
CIRSettings *settings = CIRSettings::OpenL();
iMaxPresetCount=settings->MaxPresetCount();
settings->Close();
User::LeaveIfError( iServ.Connect() );
//a session to the client of the preset server
iServ.GetPresetsL( iFavPresetList, KIRPreset );
//notifier
iNotifier = CPSPresetNotifier::NewL( iServ, *this );
//initialization of the list for UI use
//iFavPresetList=new(ELeave)CArrayPtrFlat<CIRPreset>(KGranularity)
iMoveStatus=EFalse;
IRLOG_DEBUG( "CIRFavoritesDb::ConstructL - Exiting." );
}
//---------------------------------------------------------------------------
//CIRFavoritesDb::SortByIndex()
//sorts the preset list by index
//---------------------------------------------------------------------------
//
void CIRFavoritesDb::SortByIndex()
{
IRLOG_DEBUG( "CIRFavoritesDb::SortByIndex" );
//The sort order is determined by an algorithm supplied by the caller
//and packaged as a TLinerOrder<T>
iFavPresetList.Sort( TLinearOrder<CIRPreset>( PresetHandler::OrderByIndex ) );
IRLOG_DEBUG( "CIRFavoritesDb::SortByIndex - Exiting." );
}
//---------------------------------------------------------------------------
//EXPORT_C TInt CIRFavoritesDb::MaxPresetCount()
//returns the maximum number of presets that can be stored in the favorites list
//---------------------------------------------------------------------------
//
EXPORT_C TInt CIRFavoritesDb::MaxPresetCount()
{
IRLOG_DEBUG( "CIRFavoritesDb::MaxPresetCount" );
return iMaxPresetCount;
}
//---------------------------------------------------------------------------
//TInt CIRFavoritesDb::EmptyPresetCount() const
//Returns the number of empty presets
//---------------------------------------------------------------------------
//
EXPORT_C TInt CIRFavoritesDb::EmptyPresetCount() const
{
IRLOG_DEBUG( "CIRFavoritesDb::EmptyPresetCount" );
return iMaxPresetCount - iFavPresetList.Count();
}
//---------------------------------------------------------------------------
//TInt CIRFavoritesDb::AddObserver( MPSPresetObserver& aObserver )
//Adds an observer that is notified upon changes in presets.
//---------------------------------------------------------------------------
//
EXPORT_C TInt CIRFavoritesDb::AddObserver(const MPSPresetObserver& aObserver )
{
IRLOG_DEBUG( "CIRFavoritesDb::AddObserver" );
return iObservers.InsertInAddressOrder( &aObserver );
}
//---------------------------------------------------------------------------
//TInt CIRPresetHandler::RemoveObserver( MPSPresetObserver& aObserver )
//Removes an observer for a preset.
//---------------------------------------------------------------------------
//
EXPORT_C void CIRFavoritesDb::RemoveObserver(const MPSPresetObserver& aObserver )
{
TInt idx = iObservers.FindInAddressOrder( &aObserver );
if ( idx >= 0 )
{
iObservers.Remove( idx );
iObservers.Compress();
}
}
//---------------------------------------------------------------------------
//TInt CIRFavoritesDb::MatchingPresetId( TInt aId )
//---------------------------------------------------------------------------
//
TInt CIRFavoritesDb::MatchingPresetId( TInt aId )
{
TInt indx = KErrNotFound;
SortByIndex() ;
for ( TInt i = 0; i < iFavPresetList.Count(); i++ )
{
if (iFavPresetList[i]->Id() == aId )
{
indx = iFavPresetList[i]->Index();
/*lint -save -e960 Note -- Violates MISRA Required Rule 58,
non-switch break used*/
break;
/*lint -restore */
}
}
return indx;
}
//---------------------------------------------------------------------------
//TInt CIRFavoritesDb::CreatePresetL( TInt aIndex )
//creates a preset by the index aIndex
//---------------------------------------------------------------------------
//
CIRPreset* CIRFavoritesDb::CreatePresetL( TInt aIndex )
{
IRLOG_DEBUG( "CIRFavoritesDb::CreatePresetL" );
CIRPreset* preset = static_cast<CIRPreset*>( iServ.CreatePresetL(
aIndex, KIRPreset) );
CleanupStack::PushL( preset );
iFavPresetList.AppendL( preset );
CleanupStack::Pop( preset );
IRLOG_DEBUG( "CIRFavoritesDb::CreatePresetL - Exiting." );
return preset;
}
/*
* Search a user defined preset by name and url
*/
TInt CIRFavoritesDb::SearchUserDefinedPreset(const TDesC &aName, const TDesC &aUrl)
{
TInt count = iFavPresetList.Count();
for (TInt index = 0; index < count; ++index)
{
CIRPreset *preset = iFavPresetList[index];
const TDesC &name = preset->Name();
TInt urlCount = preset->GetUrlCount();
if(preset->GetUrlCount()>0)
{
const TDesC &url = preset->GetChannelUrlAt(0);
if (preset->GetChannelType() == 0 &&
name == aName &&
url == aUrl)
{
return index;
}
}
else
{
if (preset->GetChannelType() == 0 &&
name == aName &&
aUrl == KNullDesC)
{
return index;
}
}
}
return KErrNotFound;
}
//---------------------------------------------------------------------------
//CIRFavoritesDb::PresetByIndex(TInt aIndex)
// Returns a preset by its id.
//---------------------------------------------------------------------------
//
EXPORT_C CIRPreset* CIRFavoritesDb::PresetByIndex( TInt aIndex )
{
IRLOG_DEBUG( "CIRFavoritesDb::PresetByIndex" );
CIRPreset* preset = NULL;
for ( TInt i = 0; i < iFavPresetList.Count(); i++ )
{
if (iFavPresetList[i]->Index()==aIndex)
{
preset = iFavPresetList[i];
/*lint -save -e960 (Note -- Violates MISRA Required Rule 58, non-switch break used)*/
break;
/*lint -restore*/
}
}
IRLOG_DEBUG( "CIRFavoritesDb::PresetByIndex - Exiting." );
return preset;
}
//---------------------------------------------------------------------------
// CIRFavoritesDb::PresetById(TInt aIndex)
//Returns a preset by its id.
//---------------------------------------------------------------------------
//
EXPORT_C CIRPreset* CIRFavoritesDb::PresetById( TInt aId )
{
IRLOG_DEBUG( "CIRFavoritesDb::PresetById" );
CIRPreset* preset = NULL;
for ( TInt i = 0; i < iFavPresetList.Count(); i++ )
{
if ( iFavPresetList[i]->Id() == aId )
{
preset = iFavPresetList[i];
/*lint -save -e960 Note -- Violates MISRA Required Rule 58,
non-switch break used*/
break;
/*lint -restore */
}
}
IRLOG_DEBUG( "CIRFavoritesDb::PresetById - Exiting." );
return preset;
}
//---------------------------------------------------------------------------
//CIRFavoritesDb::HandlePresetChangedL()
//function to notify a change in saved presets
//preset handler i.e CIRPreset,the reason of change.
//---------------------------------------------------------------------------
//
EXPORT_C void CIRFavoritesDb::HandlePresetChangedL( TInt aId,
TUid aDataHandler, MPSPresetObserver::TPSReason aReason )
{
IRLOG_DEBUG( "CIRFavoritesDb::HandlePresetChangedL" );
if ( aDataHandler == KIRPreset )
{
switch ( aReason )
{
case MPSPresetObserver::EPSCreated:
{
//call back from the preset client
//to append a preset when the preset is added
CPSPresetInterface* preset = NULL;
preset = PresetById( aId );
if ( !preset )
{
preset = iServ.OpenPresetL( aId );
CleanupStack::PushL( preset );
iFavPresetList.AppendL( static_cast<CIRPreset*>( preset ) );
CleanupStack::Pop( preset );
}
}
break;
case MPSPresetObserver::EPSDeleted:
{
//call back from the preset client
//to remove a preset when the preset is deleted
for ( TInt i = 0; i < iFavPresetList.Count(); i++ )
{
if ( iFavPresetList[i]->Id() == aId )
{
delete iFavPresetList[i];
iFavPresetList.Remove( i );
/*lint -save -e960 (Note -- Violates MISRA Required Rule 58, non-switch break used)*/
break;
/*lint -restore*/
}
}
}
break;
case MPSPresetObserver::EPSModified:
break;
default:
break;
}
for ( TInt i = 0; i < iObservers.Count(); i++ )
{
iObservers[i]->HandlePresetChangedL( aId, aDataHandler, aReason );
}
}
IRLOG_DEBUG( "CIRFavoritesDb::HandlePresetChangedL - Exiting." );
}