// 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);

		}

	}