/*

* Copyright (c) 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:   The source file of the CClkSrvImpl class. 

*

*/

// System includes

#include <tz.h>

#include <centralrepository.h>

#include <starterdomaincrkeys.h>

#include <ecom.h>

// User includes

#include "clockserverimpl.h"

#include "clockserver.h"

#include "clocktimesourceinterface.h"

#include "clocktimesourceinterface.hrh"

#include "clockservermcclistener.h"

#include "clocktimezoneresolver.h"

#include "clockservermccobserver.h"

#include "clockecomlistener.h"

#include "clock_debug.h"

#include "clockprivatecrkeys.h"

// Constants

const TInt KZeroIndex( 0 );

const TInt KSingleZone( 1 );

const TInt KSinglePlugin( 1 );

const TInt KSetValidNitz( 1 );

const TUid KTimeSourceInterfaceUID = { 0x200159A7 };

const TInt KNitzPlugin( 0x200159A5 );

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

// CClkSrvImpl::NewL

// rest of the details are commented in the header

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

//

CClkSrvImpl* CClkSrvImpl::NewL( CClkSrvMain* aClkSrv )

    {

    __PRINTS( "CClkSrvImpl::NewL - Entry" );

    CClkSrvImpl* clkSrvImpl = new( ELeave ) CClkSrvImpl( aClkSrv );

    CleanupStack::PushL( clkSrvImpl );

    clkSrvImpl->ConstructL();

    CleanupStack::Pop( clkSrvImpl );

    __PRINTS( "CClkSrvImpl::NewL - Exit" );

    return clkSrvImpl;

    }

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

// CClkSrvImpl::~CClkSrvImpl

// rest of the details are commented in the header

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

//

CClkSrvImpl::~CClkSrvImpl()

	{

	__PRINTS( "CClkSrvImpl::~CClkSrvImpl - Entry" );

	// Cleanup

	TInt objCount( iTimeSourceObjArray.Count() );

	// First iterate and destroy all the objects. 

	// Only removing from the array won't free the memory.

	for( TInt index ( KZeroIndex ); index < objCount; index++ )

		 {

		 CClockTimeSourceInterface* ifObject = iTimeSourceObjArray[ index ];

		 // Remove the object from the array.

		 iTimeSourceObjArray.Remove( index );

		 delete ifObject;

		 ifObject = NULL;

		 }

	// Close the handle to the array.

	iTimeSourceObjArray.Close();

	if( iMccListener )

		{

		iMccListener->Stop();

		delete iMccListener;

		iMccListener = NULL;

		}

	if( iTimeAttributes )

		{

		delete iTimeAttributes;

		iTimeAttributes = NULL;

		}

	if( iTzResolver )

		{

		delete iTzResolver;

		iTzResolver = NULL;

		}

	if( iClockEComListener )

	    {

	    delete iClockEComListener;

	    iClockEComListener = NULL;

	    }

	__PRINTS( "CClkSrvImpl::~CClkSrvImpl - Exit" );

	}

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

// CClkSrvImpl::CClkSrvImpl

// rest of the details are commented in the header

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

//

CClkSrvImpl::CClkSrvImpl( CClkSrvMain* aClkSrv ) : iClkSrv( aClkSrv ),

												   iMccReceived( EFalse ),

												   iPluginData( EFalse )

	{

	__PRINTS( "CClkSrvImpl::CClkSrvImpl - Entry" );

	// No implementation yet.

	__PRINTS( "CClkSrvImpl::CClkSrvImpl - Exit" );

	}

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

// CClkSrvImpl::ConstructL

// rest of the details are commented in the header

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

//

void CClkSrvImpl::ConstructL()

	{

	__PRINTS( "CClkSrvImpl::ConstructL - Entry" );

	// Construct and start the mcc listener.

	iMccListener = CClkMccListener::NewL( this );

	if( iMccListener )

	    {

	    iMccListener->Start();

	    }

	// Create the resolver.

	iTzResolver = CClockTimeZoneResolver::NewL();

	// Create the ECOM listener.

	TRAP_IGNORE( iClockEComListener = CClockEComListener::NewL( *this ) );

	__PRINTS( "CClkSrvImpl::ConstructL - Exit" );

	}

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

// CClkSrvImpl::ActivateAllProtocols

// rest of the details are commented in the header

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

//

TInt CClkSrvImpl::ActivateAllProtocolsL()

	{

	__PRINTS( "CClkSrvImpl::ActivateAllProtocolsL All- Entry" );	

	TInt returnVal( KErrNone );

	// Array to return all implementations in an interface.

    RImplInfoPtrArray plugInArray;

    // Get the list of all implementations.

    REComSession::ListImplementationsL( KTimeSourceInterfaceUID, plugInArray );

    TInt count( plugInArray.Count() );

    // Activate all the given protocols.

    for( TInt index( KZeroIndex ); index < count; index++ )

		 {	

		 returnVal = ActivateProtocolL( plugInArray[ index ]->ImplementationUid().iUid );		 			

		 }

    // Cleanup.

    plugInArray.ResetAndDestroy();

    plugInArray.Close();

    __PRINTS( "CClkSrvImpl::ActivateAllProtocolsL All- Exit" );

    return returnVal;	

	}

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

// CClkSrvImpl::ActivateProtocol

// rest of the details are commented in the header

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

//

TInt CClkSrvImpl::ActivateProtocolL( TInt aClkSrvProtocol )

	{

	__PRINTS( "CClkSrvImpl::ActivateProtocolL - Entry" );

	__PRINT( "The uid of the protocol being activated: %x", aClkSrvProtocol );

	TInt returnVal( KErrNone );

	// First we need to check if the plugin is already active. So we iterate through the 

	// array of plugins to see if the protocol implementation id matches with any of the 

	// plugin loaded. If not we load it.

	TBool alreadyActive( EFalse );

	// Number of plugins loaded.

	TInt pluginCount = iTimeSourceObjArray.Count();

	for( TInt index ( KZeroIndex ); index < pluginCount; index++ )

		{

		if( aClkSrvProtocol == iTimeSourceObjArray[ index ]->GetPluginUid() )

			  {

			  // We have a match, plugin is already loaded.

			  alreadyActive = ETrue;

			  break;

			  }

		}

	if( alreadyActive )

	    {

    	    // Plugin already loaded. So return.

    	    __PRINTS( "Plugin is already loaded." );    	    

    	    __PRINTS( "CClkSrvImpl::ActivateProtocolL - Exit" );

    	    return returnVal;

	    }

	if( !alreadyActive )

		  {

		  // Construct and append the object to the array.

		  CClockTimeSourceInterface* timeSourceObj( NULL );

		  timeSourceObj = CClockTimeSourceInterface::NewL( TUid::Uid( aClkSrvProtocol ),this );

		  if( !timeSourceObj )

			    {

					// The plugin could not be loaded.

		      __PRINTS( "The plugin could not be loaded." );    

		      __PRINTS( "CClkSrvImpl::ActivateProtocolL - Exit" );

		      returnVal = KErrNotFound;

		      return returnVal;

			    }

		  else

			   {

				 TInt automaticTimeUpdateState( KZeroIndex );

				 iClkSrv->GetActivePluginL( automaticTimeUpdateState );

				 // If the protocol is the default protocol for the device ,set it to On in cenrep.

				 if( !automaticTimeUpdateState || KNitzPlugin == aClkSrvProtocol )

					   {

					   iClkSrv->SetActivePluginL( ETrue );						

					   }

				 // The plugin was constructed.

				 CleanupStack::PushL( timeSourceObj );

				 // Append the constructed object to the array.

				 iTimeSourceObjArray.Append( timeSourceObj );

				 CleanupStack::Pop( timeSourceObj );

				 timeSourceObj = NULL;

				 }

		  }

	__PRINTS( "CClkSrvImpl::ActivateProtocolL - Exit" );

	return returnVal;

	}

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

// CClkSrvImpl::IsProtocolActive

// rest of the details are commented in the header

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

//

TInt CClkSrvImpl::IsProtocolActive( TBool& aIsActive, TInt aClkSrvProtocol )

	{

	__PRINTS( "CClkSrvImpl::IsProtocolActive - Entry" );

	__PRINT( "%x", aClkSrvProtocol );

	TInt returnVal( KErrNone );

	aIsActive = EFalse;

	// Get the count of objects.

	TInt arrayCount = iTimeSourceObjArray.Count();

	// Browse the array of active plugins to check if the input plugin exists 

	for(TInt index ( KZeroIndex ); index < arrayCount; index++ )

		{

		if( aClkSrvProtocol == iTimeSourceObjArray[ index ]->GetPluginUid() )

			{

			// We have a match, plugin is loaded.

			aIsActive = ETrue;

			break;

			}

		}	

	__PRINTS( "CClkSrvImpl::IsProtocolActive - Exit" );

	return returnVal;

	}

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

// CClkSrvImpl::DeActivateAllProtocols

// rest of the details are commented in the header

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

//

TInt CClkSrvImpl::DeActivateAllProtocolsL()

	{

	__PRINTS( "CClkSrvImpl::DeActivateAllProtocolsL All- Entry" );	

	TInt returnVal( KErrNone );

	// Array to return all implementations in an interface.

  RImplInfoPtrArray plugInArray;

  // Get the list of all implementations.

  REComSession::ListImplementationsL( KTimeSourceInterfaceUID, plugInArray ); 

  // Set the cendrep key for Automatic time update status to off.

  TInt automaticTimeUpdateState( KZeroIndex );

	iClkSrv->GetActivePluginL( automaticTimeUpdateState );

	if( automaticTimeUpdateState )

			{				

			iClkSrv->SetActivePluginL( EFalse );				

			}			

  // Deactivate all the given protocols.

  for( TInt index( KZeroIndex ); index < plugInArray.Count(); index++ )

	     {	

		   returnVal = DeActivateProtocolL( plugInArray[ index ]->ImplementationUid().iUid );		 			

		   }

  // Cleanup.

  plugInArray.ResetAndDestroy();

  plugInArray.Close();

  __PRINTS( "CClkSrvImpl::DeActivateAllProtocolsL All- Exit" );

  return returnVal;

	}

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

// CClkSrvImpl::DeActivateProtocolL

// rest of the details are commented in the header

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

//	

TInt CClkSrvImpl::DeActivateProtocolL( TInt aClkSrvProtocol )

	{

	__PRINTS( "CClkSrvImpl::DeActivateProtocolL - Entry" );

	__PRINT( "The uid of the protocol being deactivated :%x", aClkSrvProtocol );

	TInt returnVal( KErrNotFound );

	// Get the count of objects.

	TInt arrayCount = iTimeSourceObjArray.Count();

	// Browse every active plugin object to find the match.

	for( TInt index( KZeroIndex ) ; index < arrayCount; index++ )

		 {

		 if( aClkSrvProtocol == iTimeSourceObjArray[ index ]->GetPluginUid() )

			 {

			 // set the state it to Off in cenrep

			 TInt automaticTimeUpdateState( KZeroIndex );						

			 iClkSrv->GetActivePluginL( automaticTimeUpdateState );

			 if( ( automaticTimeUpdateState ) && ( KSinglePlugin == arrayCount  ) )

				   {				

				   iClkSrv->SetActivePluginL( EFalse );				

				   }			

			 // We have a match, plugin is loaded. Now destroy it.

			 CClockTimeSourceInterface* ifObject = iTimeSourceObjArray[ index ];

			 CleanupStack::PushL( ifObject );

			 // Remove from the array.

			 iTimeSourceObjArray.Remove( index );

			 // Free the memory.

			 CleanupStack::PopAndDestroy( ifObject );

			 returnVal = KErrNone;

			 break;

			 }

		 }

	__PRINTS( "CClkSrvImpl::DeActivateProtocolL - Exit" );

	return returnVal;

	}

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

// CClkSrvImpl::GetProtocolInformationL()

// rest of the details are commented in the header

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

//

TInt CClkSrvImpl::GetProtocolInformationL( STimeAttributes& aTimeInformation )

	{

	__PRINTS( "CClkSrvImpl::GetProtocolInformationL - Entry" );

	TInt returnValue( KErrNotFound );

	if( iTimeAttributes )

		{

		returnValue = KErrNone;

		// Assign the time information.

		aTimeInformation = *iTimeAttributes;

		}

	__PRINTS( "CClkSrvImpl::GetProtocolInformationL - Exit" );

	return returnValue;

	}

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

// CClkSrvImpl::GetCurrentMccL()

// rest of the details are commented in the header

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

//

TInt CClkSrvImpl::GetCurrentMccL( TInt& aCurrentMcc )

	{

	__PRINTS( "CClkSrvImpl::GetCurrentMccL - Entry" );

	TInt returnValue( KErrNotFound );

	if( iMccReceived )

		{

		TLex currentMcc;

		currentMcc.Assign( iMcc );

		// Return the value

		currentMcc.Val( aCurrentMcc );

		returnValue = KErrNone;

		__PRINT( "Current MCC - %d", aCurrentMcc );

		}

	__PRINTS( "CClkSrvImpl::GetCurrentMccL - Exit" );

	return returnValue;

	}

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

// CClkSrvImpl::GetCurrentTimeZoneIdL()

// rest of the details are commented in the header

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

//

TInt CClkSrvImpl::GetCurrentTimeZoneIdL( TInt& aCurrentTimeZoneId )

	{

	__PRINTS( "CClkSrvImpl::GetCurrentTimeZoneIdL - Entry" );

	TInt returnValue( KErrNotFound );

	if( 0 != iTimeZoneId )

		{

		// Assign the value

		aCurrentTimeZoneId = iTimeZoneId;

		returnValue = KErrNone;

		}

	__PRINT( "Current timezone ID: %d", iTimeZoneId );

	__PRINTS( "CClkSrvImpl::GetCurrentTimeZoneIdL - Exit" );

	return returnValue;

	}

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

// CClkSrvImpl::IsAutoTimeUpdateOn

// rest of the details are commented in the header

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

//

TInt CClkSrvImpl::IsAutoTimeUpdateOn( TBool& aEnabled )

    {

    __PRINTS( "CClkSrvImpl::IsAutoTimeUpdateOn - Entry" );

    TInt returnValue( KErrNone );

    // If the array has any items, it means atleast one of the protocols is active.

    aEnabled = iTimeSourceObjArray.Count() ? ETrue : EFalse;

    __PRINTS( "CClkSrvImpl::IsAutoTimeUpdateOn - Exit" );

    return returnValue;

    }

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

// CClkSrvImpl::NotifyTimeChangeL()

// rest of the details are commented in the header

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

//

void CClkSrvImpl::NotifyTimeChangeL( CClockTimeSourceInterface& aPluginImpl )

	{

	__PRINTS( "CClkSrvImpl::NotifyTimeChangeL - Entry" );

	// Construct the time attributes holder struct object.

	if( !iTimeAttributes )

		{

		TRAPD( errVal, iTimeAttributes = new( ELeave ) STimeAttributes );

		if( KErrNone != errVal )

		    {

		    __PRINTS( "Could not construct time attributes holder" );

		    __PRINTS( "CClkSrvImpl::NotifyTimeChangeL - Exit" );

		    return;

		    }

		}

	// Get all the information related to the plugin.

	// The UTC time.

	TRAP_IGNORE( aPluginImpl.GetTimeInformationL( EUTCTime, iTimeAttributes ) );	

	// The default offset.

	TRAP_IGNORE( aPluginImpl.GetTimeInformationL( ETZOffset, iTimeAttributes ) );

	// The dst offset.

	TRAP_IGNORE( aPluginImpl.GetTimeInformationL( EDSTOffset, iTimeAttributes ) );

	// Set a flag saying we have plugin data.

	iPluginData = ETrue;

	// Get the first boot status from cenrep. If it is the first boot, clockserver will not update the time.

	TBool staleBoot( EFalse );

	CRepository* cenRep( NULL );

	TRAPD( errorVal, cenRep = CRepository::NewL( KCRUidStartup ) );