/*

* Copyright (c) 2000 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: Implementation of policymanagement components

*

*/

// INCLUDES

#include "DMUtilObserver.h"

#include "DMUtilActiveObserver.h"

#include "PMUtilInternalCRKeys.h"

#include "policymnginternalpskeys.h"

#include "debug.h"

#include <s32file.h>

#include <centralrepository.h>

#include <e32property.h>

// CONSTANTS

_LIT( KPolicyChangeCounterIni, "pcounter.ini");

_LIT( KRFSCounterIni, "rfscounter.ini");

// MACROS

// DATA TYPES

// FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

namespace ObserverUtils

{

	TBool CheckValueL( const TDesC& aFile, const TUint32& aCentRepKey)

	{

		TBool retVal = EFalse;

		CRepository* repository = CRepository::NewLC( KCRUidPolicyManagementUtilInternalKeys);

		//get counter value from central repository			

		TInt counterPreValue(0);

		TInt counterRealValue(0);

		User::LeaveIfError( repository->Get( aCentRepKey, counterRealValue));			

		CleanupStack::PopAndDestroy( repository);

		//create binary presentation for values

		TPckg<TInt> realCounterPack( counterRealValue);			

		TPckg<TInt> preCounterPack( counterPreValue);			

		//Open file	

		RFs rfs;

		User::LeaveIfError( rfs.Connect());			

		CleanupClosePushL( rfs);

		RFile file;

		CleanupClosePushL( file);

		TBuf<100> fullName;

		User::LeaveIfError( rfs.PrivatePath( fullName));

		fullName.Append( aFile);	

		TInt err = file.Open( rfs, fullName, EFileRead|EFileWrite);

		if ( err == KErrPathNotFound)

		{

			//create private path if not exists

			User::LeaveIfError( rfs.CreatePrivatePath( EDriveC));

			err = KErrNotFound;

		}

		if ( err == KErrNotFound)

		{

			//create file with current counter value

			User::LeaveIfError( file.Create( rfs, fullName, EFileRead|EFileWrite));			

			User::LeaveIfError( file.Write( realCounterPack));

			User::LeaveIfError( file.Flush());

		}

		else

		{

			//read pre-counter value

			User::LeaveIfError( err);

			User::LeaveIfError( file.Read( preCounterPack));

			if ( counterPreValue != counterRealValue)

			{

				//if counter values has changed, changes return value and update pre-value...

				retVal = ETrue;

				TInt offset(0);

				User::LeaveIfError( file.Seek( ESeekStart, offset));

				User::LeaveIfError( file.Write( realCounterPack));

				User::LeaveIfError( file.Flush());

			}

		}

		//close sessions				

		CleanupStack::PopAndDestroy( 2, &rfs);			

		return retVal;

	}

}

// -----------------------------------------------------------------------------

// TDMUtilPassiveObserver::IsPolicyChangedL

// -----------------------------------------------------------------------------

//

EXPORT_C TBool TDMUtilPassiveObserver::IsPolicyChangedL()

{

	return ObserverUtils::CheckValueL( KPolicyChangeCounterIni, KPolicyChangeCounter);		

}

// -----------------------------------------------------------------------------

// TDMUtilStaticObserver::IsRFSPerformedL

// -----------------------------------------------------------------------------

//

EXPORT_C TBool TDMUtilPassiveObserver::IsRFSPerformedL()

{

	return ObserverUtils::CheckValueL( KRFSCounterIni, KRFSCounterKey );		

}

// -----------------------------------------------------------------------------

// CDMUtilActiveObserver::CDMUtilActiveObserver

// -----------------------------------------------------------------------------

//

CDMUtilActiveObserver::CDMUtilActiveObserver()

	: iActiveObserver(0)

{

}

// -----------------------------------------------------------------------------

// CDMUtilActiveObserver::~CDMUtilActiveObserver

// -----------------------------------------------------------------------------

//

CDMUtilActiveObserver::~CDMUtilActiveObserver()

{

	delete iActiveObserver;

}

// -----------------------------------------------------------------------------

// CDMUtilActiveObserver::NewL

// -----------------------------------------------------------------------------

//

EXPORT_C CDMUtilActiveObserver* CDMUtilActiveObserver::NewL( TPolicyManagementEventTypes aType)

{

	CDMUtilActiveObserver* self = new (ELeave) CDMUtilActiveObserver();

	CleanupStack::PushL( self);

	self->iActiveObserver = CActiveObserver::NewL( aType);

	CleanupStack::Pop( self);

	return self;

}

// -----------------------------------------------------------------------------

// CDMUtilActiveObserver::SubscribeEventL

// -----------------------------------------------------------------------------

//

EXPORT_C void CDMUtilActiveObserver::SubscribeEventL( MActiveCallBackObserver* aDynamicCallBackObserver)

{

	iActiveObserver->SubscribeEventL( aDynamicCallBackObserver);

}

// -----------------------------------------------------------------------------

// CDMUtilActiveObserver::UnSubscribeEventL

// -----------------------------------------------------------------------------

//

EXPORT_C void CDMUtilActiveObserver::UnSubscribeEvent()

{

	iActiveObserver->UnSubscribeEvent();

}

// -----------------------------------------------------------------------------

// CActiveObserver::CActiveObserver

// -----------------------------------------------------------------------------

//

CActiveObserver::CActiveObserver( TPolicyManagementEventTypes aType) 

	: CActive(0), type( aType), iSubscribed( 0)

{

}

// -----------------------------------------------------------------------------

// CActiveObserver::~CActiveObserver

// -----------------------------------------------------------------------------

//

CActiveObserver::~CActiveObserver()

{

	iProperty.Close();

	iSubcribers.Close();

	Deque();

}

// -----------------------------------------------------------------------------

// CActiveObserver::NewL

// -----------------------------------------------------------------------------

//

CActiveObserver* CActiveObserver::NewL( TPolicyManagementEventTypes aType)

{

	CActiveObserver* self = new (ELeave) CActiveObserver( aType);

	return self;

}

// -----------------------------------------------------------------------------

// CActiveObserver::SubscribeEventL

// -----------------------------------------------------------------------------

//

void CActiveObserver::SubscribeEventL( MActiveCallBackObserver* aDynamicCallBackObserver)

{

	//add subsribers info to list

	iSubcribers.Append( aDynamicCallBackObserver);

	if ( !iSubscribed)

	{

		//subscribe event 

		TUint32 key = SubscribeKey( type);

		iProperty.Attach( KPolicyMngProperty, key);

		iProperty.Subscribe( iStatus);

		//init....

		CActiveScheduler::Add( this);

		SetActive();

	}

	iSubscribed = ETrue;

}

// -----------------------------------------------------------------------------

// CActiveObserver::UnSubscribeEventL

// -----------------------------------------------------------------------------

//

TUint32 CActiveObserver::SubscribeKey( TPolicyManagementEventTypes aType)

{

	TUint32 retVal = 0;

	switch ( aType)

	{

		case EPolicyChangedEvent:

			retVal = KPolicyChangedCounter;

		break;

		default:

		break;

	}

	return retVal;

}

// -----------------------------------------------------------------------------

// CActiveObserver::UnSubscribeEventL

// -----------------------------------------------------------------------------

//

void CActiveObserver::UnSubscribeEvent()

{

	DoCancel();

	iSubscribed = EFalse;

}

// -----------------------------------------------------------------------------

// CActiveObserver::UnSubscribeEventL

// -----------------------------------------------------------------------------

//

void CActiveObserver::RunL()

{	

	//notify subscribers....

	for ( TInt i(0); i < iSubcribers.Count(); i++)

	{

		iSubcribers[i]->EventLaunchedL();

	}

	//subscribe again...	

	SetActive();

	iProperty.Subscribe( iStatus);	

}

// -----------------------------------------------------------------------------

// CActiveObserver::DoCancel

// -----------------------------------------------------------------------------

//

void CActiveObserver::DoCancel()

{

	iProperty.Close();

	iSubcribers.Reset();

}