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

#include "pairingscache.h"
#include "linkutil.h"

/*static*/ CBTPairingsCache* CBTPairingsCache::NewL(MBTPairingsCacheObserver& aObserver, RBTRegServ& aRegServ)
	{
	CBTPairingsCache* self = new(ELeave) CBTPairingsCache(aObserver);
	CleanupStack::PushL(self);
	self->ConstructL(aRegServ);
	CleanupStack::Pop(self);
	return self;
	}

CBTPairingsCache::CBTPairingsCache(MBTPairingsCacheObserver& aObserver)
	: iObserver(aObserver)
	{
	}

void CBTPairingsCache::ConstructL(RBTRegServ& aRegServ)
	{
	iBTPairedBDAddrGetter = CBTPairedBDAddrGetter::NewL(*this, aRegServ);
	DoUpdateCache();
	}

CBTPairingsCache::~CBTPairingsCache()
	{
	delete iBTPairedBDAddrGetter;
	iPairedBDAddrs.Close();
	}

void CBTPairingsCache::UpdateCache()
	{
	// First we must cancel any outstanding request, as this will be called
	// when the registry has been modified an an external (API) user, and
	// so an in progress 'get' may have a stale view.
	iBTPairedBDAddrGetter->Cancel();
	DoUpdateCache();
	}

void CBTPairingsCache::DoUpdateCache()
	{
    RemoveAllPairedDevices(); // Clear out the cache as it may be stale.
	iCacheState = EUpdateOutstanding;
	iBTPairedBDAddrGetter->Retrieve();
	}

CBTPairingsCache::TPairingState CBTPairingsCache::IsPaired(const TBTDevAddr& aBDAddr)
	{
	// We initially assume that there is no pairing to the remote device.
    CBTPairingsCache::TPairingState ret = ENotPaired;
    
    // We determine whether they are in our pairing cache or not.
    TBool inPairingCache = InPairingCache(aBDAddr);

	// Now we do some additional work based on the state of the cache.
	switch(iCacheState)
		{
	case EUpdateOutstanding:
		// If an update has been requested then we make them
		// wait for the answer.
		ret = EDeferred;
		break;
	case EUpdateFailed:
		// If we failed last time we should try again, and tell
		// them to wait for the answer.
		DoUpdateCache();
		ret = EDeferred;
		break;
	case EValid:
		// If the cache is valid then either we are paired or
		// we aren't, the answer to which is based on whether they
		// are in the cache or not.
		break;
	default:
		Panic(EBTPairingsCacheBadState);
		break;
		}

	// If we were already in the cache then that means there must be a pairing.
	if(inPairingCache)
		{
		ret = EPaired;
		}

	// If we are deferring the decision about whether paired or not, then we 
	// need to remember that we should inform the observer when we have 
	// completed our attempt at getting an answer.
	if(ret == EDeferred)
		{
		iDeferredDecision = ETrue;
		}

	return ret;
	}

TBool CBTPairingsCache::InPairingCache(const TBTDevAddr& aBDAddr)
	{
	return (PairedDeviceIndex(aBDAddr) >= 0) ? ETrue : EFalse;
	}

/**
Wrapper for TBTDevAddr's == operation.
This is needed by the TIdentityRelation parameter in RArray's Find method.
*/
/*static*/ TBool CBTPairingsCache::AreBDAddrsEqual(const TBTDevAddr& aA, const TBTDevAddr& aB)
	{
	return aA == aB;
	}

/**
Returns either the index of the remote device address in the
paired device address list if the specified address is
included therein or KErrNotFound if not
*/
TInt CBTPairingsCache::PairedDeviceIndex(const TBTDevAddr& aBDAddr)
	{
	TIdentityRelation<TBTDevAddr> rel(AreBDAddrsEqual);
	return iPairedBDAddrs.Find(aBDAddr, rel);
	}

TInt CBTPairingsCache::AddPairedDevice(const TBTDevAddr& aAddr)
	{
    __ASSERT_DEBUG(aAddr!=0, Panic(EBTConnectionBadDeviceAddress));
	
	TInt err = KErrNone;
	if(!InPairingCache(aAddr))
		{
		err = iPairedBDAddrs.Append(aAddr);
		}
	return err;
	}

void CBTPairingsCache::RemoveAllPairedDevices()
	{
	for(TInt i=iPairedBDAddrs.Count()-1; i>=0; i--)
		{
		iPairedBDAddrs.Remove(i);
		}
	}

void CBTPairingsCache::InformObserver(TInt aError)
	{
    // Ensure that we inform the observer only if they have been deferred.
	if(iDeferredDecision)
		{
		iDeferredDecision = EFalse;
		iObserver.MbpcoDeferredDecisionResolved(aError);
		}
	}

/*virtual*/ void CBTPairingsCache::MbpdnAddPairedDevices(const RBTDeviceArray& aAddrs)
	{
	__ASSERT_DEBUG(iCacheState == EUpdateOutstanding, Panic(EBTPairingsCacheBadState));
	
	// check that the cache is still empty
	__ASSERT_DEBUG(iPairedBDAddrs.Count() == 0, Panic(EBTPairingsCacheNotEmpty));
	
	TInt err = KErrNone;

	TInt count = aAddrs.Count();
	for (TInt i=0; i<count; i++)
		{
		err = AddPairedDevice(aAddrs[i]->BDAddr());
		if(err != KErrNone)
			{
			break;
			}
		}

	// We handle add failures ourselves.
	iCacheState = (err == KErrNone) ? EValid : EUpdateFailed;

	// We inform the observer, even if there was an error because it is
	// possible that we managed to get the address they were after.
	InformObserver(err);
	}

/*virtual*/ void CBTPairingsCache::MbpdnErrorInGettingPairedDevices(TInt aError)
	{
	__ASSERT_DEBUG(iCacheState == EUpdateOutstanding, Panic(EBTPairingsCacheBadState));
	// Current cache should be ok - we should have cleared it before a getter is
	// started.  This simply sets the flag to indicate that the current (empty) cache 
	// is either complete if aErr is KErrNotFound (or KErrNone) or incomplete
	// if aErr is anything else. In the latter case if the cache is needed in future 
	// another getter should be kicked off.
	TInt err = (aError != KErrNone && aError != KErrNotFound) ? aError : KErrNone;
	if(err != KErrNone)
		{
		iCacheState = EUpdateFailed;
		}
	else
		{
		iCacheState = EValid;
		}
	
	// Ensure that if we have been queried about the pairings and deferred the
	// client, they must be informed.
	InformObserver(err);
	}