// Copyright (c) 2006-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:

 //

 /**

  @file

  @internalTechnology

 */

 #include <s32mem.h>

 #include "BaSsndStore.h"

 #include "BASSNDUID.h"

 // The repository format is: one setting for MajorUID, one

 // setting for sound type, one setting for the actual sound

 // data, and then leave one key space empty to round up to

 // power of 2.

 const TUint32 KSoundCatPartialKey = 0x1;

 const TUint32 KSoundTypePartialKey = 0x2;

 const TUint32 KSoundSettingPartialKey = 0x3;

 const TUint32 KNumUnusedKeySpace = 1;

 const TUint32 KSsndKeyMask = 0x3;

 const TUint32 KKeyOffsetFromSoundType = 

 	KSoundSettingPartialKey - KSoundTypePartialKey;

 const TUint32 KKeyOffsetFromSoundCat = 

 	KSoundSettingPartialKey - KSoundCatPartialKey;

 const TUint32 KSsndBlockSize = KSoundSettingPartialKey + KNumUnusedKeySpace;

 /** static factory method to instantiate an instance of CBaSsndStore */

 CBaSsndStore* CBaSsndStore::NewL()

 	{

 	CBaSsndStore* self = new(ELeave)CBaSsndStore;

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop();

 	return self;

 	}

 /** CBaSsndStore constructor */

 CBaSsndStore::CBaSsndStore()

 	{

 	}

 /** standard two phase construction to setup the CBaSsndStore object */

 void CBaSsndStore::ConstructL()

 	{

 	iRepository = CRepository::NewL(KSystemSoundRepositoryUID);

 	}

 /** CBaSsndStore destructor */

 CBaSsndStore::~CBaSsndStore()

 	{

 	delete iRepository;

 	}

 /** Retrieve sound data from repository.

 @param aSoundType identifies the sound to retrieve.

 @param aInfo contains the sound data on return.

 @leave any of the system-wide error codes.

 */

 void CBaSsndStore::GetSoundL(const TBaSystemSoundType& aSoundType,

 							 TBaSystemSoundInfo& aInfo) const

 	{

 	TUint32 key;

 	FindKeyL(aSoundType, key, EFalse);

 	HBufC8* hbuf8 = HBufC8::NewLC(sizeof(TBaSystemSoundInfo));

 	TPtr8 buf8 = hbuf8->Des();

 	User::LeaveIfError(iRepository->Get(key + KKeyOffsetFromSoundType, buf8));

 	RDesReadStream strm(buf8);

 	aInfo.InternalizeL(strm);

 	CleanupStack::PopAndDestroy(hbuf8);

 	if (! (aSoundType == aInfo.iType))

 		{

 		User::Leave(KErrCorrupt);

 		}

 	}

 /** Search for a sound from storage and return the sound data.

 @param aInfo as input contains the ID of the sound instance to

 	get. As output, return the sound info if operation successful. 

 @return KErrNone if successful, otherwise KErrNotFound or

 	any other system-wide errors.

 */

 TInt CBaSsndStore::GetSound(const TBaSystemSoundType& aSoundType,

 							TBaSystemSoundInfo& aInfo) const

 	{

 	TRAPD(err, GetSoundL(aSoundType, aInfo));

 	return err;

 	}

 /**

 Overwrite existing sound if it is already in sound table.

 Add it if it does not exist.

 @param aInfo the sound data to save in repository.

 @leave one of the system-wide errors if set fails.

 */

 void CBaSsndStore::SetSoundL(const TBaSystemSoundInfo& aInfo) const

 	{

 	HBufC8* hbuf8 = HBufC8::NewLC(sizeof(TBaSystemSoundInfo));

 	TPtr8 buf8 = hbuf8->Des();

 	RDesWriteStream writeStream( buf8 );

 	aInfo.ExternalizeL(writeStream);

 	writeStream.CommitL();

 	TBaSystemSoundType ssType(aInfo.iType);

 	// If two threads simultaneously add sound, one of them

 	// will fail. Hence retry.

 	const TInt KMaxRetryTransaction = 3;

 	TInt err(KErrLocked);

 	for (TInt i = 0; 

 		 (i < KMaxRetryTransaction) && (err == KErrLocked || err == KErrAbort);

 		 i++)

 		{

 		TRAP(err, SetSoundInTransactionL(ssType, buf8));

 		}

 	CleanupStack::PopAndDestroy(hbuf8);

 	User::LeaveIfError(err);

 	}

 /** If the given sound type exists in repository it is over written.

 If not exists, create a new entry. This modify/create logic must be

 wrapped in a CentRep transaction.

 @param aSoundType Use this unique indentifier to find

        if the sound already exists in repository. If it exists

 	   use Set. If not, use Create.

 @param aDes8 contains the sound data streamed to a TDesC8 buffer.

 @leave any of the system-wide errors.

 */

 void CBaSsndStore::SetSoundInTransactionL(TBaSystemSoundType& aSoundType,

 										  const TDesC8& aDes8) const

 	{

 	User::LeaveIfError( iRepository->StartTransaction(CRepository::EConcurrentReadWriteTransaction) );

 	iRepository->CleanupCancelTransactionPushL();

 	TUint32 errorId;

 	TUint32 key;

 	KeyOfSoundTypeL(aSoundType, key);

 	if (key != NCentralRepositoryConstants::KUnspecifiedKey)

 		{

 		User::LeaveIfError(iRepository->Set(key + KKeyOffsetFromSoundType, aDes8));

 		User::LeaveIfError(iRepository->CommitTransaction(errorId));

 		CleanupStack::Pop(); // transaction

 		return;

 		}

 	FindNextEmptySlotL(key);

 	TPckg<TBaSystemSoundUid> ssuid(aSoundType.iMajor);

 	User::LeaveIfError(iRepository->Create(key++, ssuid));

 	TPckg<TBaSystemSoundType> sstype(aSoundType);

 	User::LeaveIfError(iRepository->Create(key++, sstype));

 	User::LeaveIfError(iRepository->Create(key, aDes8) );

 	User::LeaveIfError(iRepository->CommitTransaction(errorId));

 	CleanupStack::Pop(); // transaction

 	}

 /** Get all instances of a sound category

 @param aSSUid identifies the category to retrieve.

 @param aArray output parameter to return the sound instances

 @return KErrNone if successful, else one of the system-wide error codes

 */

 TInt CBaSsndStore::GetSoundCategory(const TBaSystemSoundUid& aSSUid,

 									CArrayFixFlat<TBaSystemSoundInfo>& aArray) const

 	{

 	TRAPD(ret, GetSoundCategoryL(aSSUid, aArray));

 	return ret;

 	}

 /** Get all instances of a sound category.

 @param aSSUid identifies the category to retrieve.

 @param aArray output parameter to return the sound instances.

 @leave any of the system-wide error codes.

 */

 void CBaSsndStore::GetSoundCategoryL(const TBaSystemSoundUid& aSSUid,

 									 CArrayFixFlat<TBaSystemSoundInfo>& aArray) const

 	{

 	RArray<TUint32> keys;

 	FindKeyL(aSSUid, keys);

 	CleanupClosePushL(keys);

 	HBufC8* hbuf8 = HBufC8::NewLC(sizeof(TBaSystemSoundInfo));

 	TPtr8 buf8 = hbuf8->Des();

 	TBaSystemSoundInfo* sound = new(ELeave) TBaSystemSoundInfo;

 	CleanupStack::PushL(sound);

 	TInt n = keys.Count();

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

 		{

 		User::LeaveIfError(iRepository->Get(

 			keys[i] + KKeyOffsetFromSoundCat, buf8));

 		RDesReadStream strm(buf8);

 		sound->InternalizeL(strm);

 		aArray.AppendL(*sound);

 		}

 	CleanupStack::PopAndDestroy(sound);

 	CleanupStack::PopAndDestroy(hbuf8);

 	CleanupStack::PopAndDestroy(&keys);

 	}

 /**

 Search for a sound instance in repository.

 @param aSoundType identifies the TBaSystemSoundType to search for.

 @param aKey output parameter containing the key of the sound type.

 @param aNoLeaveIfNotFound indicate whether this method should leave if

 		the sound type is not found.

 @leave KErrNotFound if not found, plus other system-wide errors.

 */

 void CBaSsndStore::FindKeyL(const TBaSystemSoundType& aSoundType,

 							TUint32& aKey,

 							TBool aNoLeaveIfNotFound) const

 	{

 	aKey = NCentralRepositoryConstants::KUnspecifiedKey;

 	TBaSystemSoundType soundTypeCopy = aSoundType;

 	TPckg<TBaSystemSoundType> target(soundTypeCopy);

 	RArray<TUint32> foundIds;

 	TInt ret = iRepository->FindEqL(KSoundTypePartialKey, 

 		KSsndKeyMask, target, foundIds);

 	if (ret == KErrNotFound && aNoLeaveIfNotFound)

 		{

 		return;

 		}

 	User::LeaveIfError(ret);

 	aKey = foundIds[0];

 	foundIds.Reset();

 	}

 /**

 Search for a sound category

 @param aSSUid the sound category to search for.

 @param aKeys output parameter containing keys having the sound category

 		as their values.

 @leave KErrNotFound if not found, plus other system-wide errors.

 */

 void CBaSsndStore::FindKeyL(const TBaSystemSoundUid& aSSUid, RArray<TUint32>& aKeys) const

 	{

 	TBaSystemSoundUid ssuidCopy = aSSUid;

 	TPckg<TBaSystemSoundUid> target(ssuidCopy);

 	User::LeaveIfError( iRepository->FindEqL(KSoundCatPartialKey, 

 		KSsndKeyMask, target, aKeys) );

 	}

 /** Call FindKeyL with aNoLeaveIfNotFound parameter set to true.

 Used in SetSound to intercept and save the key.

 @param aSoundType is the sound type to search for.

 @param aKey output parameter to hold the key of the sound type.

 @see CBaSsndStore::FindKeyL

 */

 void CBaSsndStore::KeyOfSoundTypeL(TBaSystemSoundType& aSoundType,

 								   TUint32& aKey) const

 	{

 	FindKeyL(aSoundType, aKey, ETrue);

 	}

 /**

 Find the next unused key to append a new sound.

 @param aKey on return contains the key to use to store

 	the next sound.

 @leave any of the system-wide error codes.

 */

 void CBaSsndStore::FindNextEmptySlotL(TUint32& aKey) const

 	{

 	RArray<TUint32> foundIds;

 	TInt ret = iRepository->FindL(KSoundSettingPartialKey,

 		KSsndKeyMask, foundIds);

 	if (ret == KErrNotFound)

 		{

 		// Empty repository. Start storing at key 1

 		aKey = 1;

 		}

 	else if (ret == KErrNone)

 		{

 	    // The array is sorted. The max key is the last one in array.

 		TInt n = foundIds.Count();

 		TUint32 maxkey = foundIds[n-1];

 		foundIds.Reset();

 		TUint32 expectedArraySize = maxkey / KSsndBlockSize + 1;

 		if (expectedArraySize > n)

 			{

 			// Rogue app bypassed BaSystemSound and added non-contiguous

 			// entries in repository.

 			User::Leave(KErrCorrupt);

 			}

 		// next record to be stored at maxkey + 2

 		aKey = maxkey + KNumUnusedKeySpace + 1;

 		}

 	else

 		{

 		User::Leave(ret);

 		}

 	}