// 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:
// Name          : TimerValueRetriever.cpp
// Part of       : TransactionUser
// Version       : SIP/5.0
//



#include <centralrepository.h>
#include "SIPSDKCRKeys.h"
#include "SipAssert.h"
#include "TimerValueRetriever.h"


// -----------------------------------------------------------------------------
// CTimerValueRetriever::NewL
// -----------------------------------------------------------------------------
//
CTimerValueRetriever* CTimerValueRetriever::NewL()
	{
    CTimerValueRetriever* self = new (ELeave) CTimerValueRetriever();
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

// -----------------------------------------------------------------------------
// CTimerValueRetriever::CTimerValueRetriever
// -----------------------------------------------------------------------------
//
CTimerValueRetriever::CTimerValueRetriever() :
	CActive(EPriorityStandard)
	{
	CActiveScheduler::Add(this);
	}

// -----------------------------------------------------------------------------
// CTimerValueRetriever::ConstructL
// -----------------------------------------------------------------------------
//
void CTimerValueRetriever::ConstructL()
	{
	iRepository = CRepository::NewL(KCRUidSIP);
	ReadValuesL();
	for(TUint i = 0; i < EMaxSupportedBearer;i++)
		__ASSERT_ALWAYS(iTimerValues[i].CheckValues(), User::Leave(KErrCorrupt));
	ListenForChangesL();
	}

// -----------------------------------------------------------------------------
// CTimerValueRetriever::~CTimerValueRetriever
// -----------------------------------------------------------------------------
//
CTimerValueRetriever::~CTimerValueRetriever()
	{
	Cancel();
	delete iRepository;
	}

// -----------------------------------------------------------------------------
// CTimerValueRetriever::DoCancel
// -----------------------------------------------------------------------------
//
void CTimerValueRetriever::DoCancel()
	{
	if (iRepository)
		{
		iRepository->NotifyCancelAll();
		}
	}

// -----------------------------------------------------------------------------
// CTimerValueRetriever::RunL
// -----------------------------------------------------------------------------
//
void CTimerValueRetriever::RunL()
	{
	__SIP_ASSERT_LEAVE(iRepository, KErrNotFound);

	// In S60, repository completes the notification request with value 1, even
	// though there is no error.
	if (iStatus.Int() >= KErrNone)
		{
		ReadValuesL();
		}

	ListenForChangesL();
	}

// -----------------------------------------------------------------------------
// CTimerValueRetriever::RunError
// -----------------------------------------------------------------------------
//
TInt CTimerValueRetriever::RunError(TInt aError)
	{
	return (aError == KErrNoMemory) ? aError : KErrNone;
	}

// -----------------------------------------------------------------------------
// CTimerValueRetriever::TimerValues
// -----------------------------------------------------------------------------
//
TTimerValues& CTimerValueRetriever::TimerValues(BearerType aType)
	{
	if(EMaxSupportedBearer > aType)
		return iTimerValues[aType];
	else
		return iTimerValues[EModemBearer];
	}
	
// -----------------------------------------------------------------------------
// CTimerValueRetriever::ReadValuesL
// If the values read from repository are invalid, use the previous values.
// -----------------------------------------------------------------------------
//
void CTimerValueRetriever::ReadValuesL()
	{
	__SIP_ASSERT_LEAVE(iRepository, KErrNotFound);

    TInt t1 = 0;
    TInt t2 = 0;
    TInt t4 = 0;

    User::LeaveIfError(iRepository->Get(KSIPTransactionTimerT1, t1));
    User::LeaveIfError(iRepository->Get(KSIPTransactionTimerT2, t2));
    User::LeaveIfError(iRepository->Get(KSIPTransactionTimerT4, t4));

	TTimerValues newMBValues(t1, t2, t4);
	if (newMBValues.CheckValues())
		{
		iTimerValues[EModemBearer] = newMBValues;
		}
	
	User::LeaveIfError(iRepository->Get(KSIPTransactionTimerLANT1, t1));
	User::LeaveIfError(iRepository->Get(KSIPTransactionTimerLANT2, t2));
	User::LeaveIfError(iRepository->Get(KSIPTransactionTimerLANT4, t4));

	TTimerValues newLBValues(t1, t2, t4);
	if (newLBValues.CheckValues())
		{
		iTimerValues[ELanBearer] = newLBValues;
		}
    }

// -----------------------------------------------------------------------------
// CTimerValueRetriever::ListenForChangesL
// -----------------------------------------------------------------------------
//
void CTimerValueRetriever::ListenForChangesL()
	{
	__SIP_ASSERT_LEAVE(iRepository, KErrNotFound);

	const TUint32 KDummyPartialKey = 0x0;
	//This mask means listening for all keys 
	const TUint32 KMaskIncludingAllKeys = 0x0;

	User::LeaveIfError(iRepository->NotifyRequest(KDummyPartialKey,
												  KMaskIncludingAllKeys,
												  iStatus));
	SetActive();
	}

// -----------------------------------------------------------------------------
// CTimerValueRetriever::HighestT1Value
// -----------------------------------------------------------------------------
//
TUint CTimerValueRetriever::HighestT1()
	{
	TUint t1 = 0;
	for(TUint i = 0; i < EMaxSupportedBearer;i++)
		if(iTimerValues[i].T1() > t1)
			t1 = iTimerValues[i].T1();
	return t1;
	}