/*
* Copyright (c) 2008 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 CClkSrvSession class.
*
*/

// System includes

// User includes
#include "clockserver.h"
#include "clockserversession.h"
#include "clockservercmds.h"
#include "clockserverimpl.h"
#include "clock_debug.h"
#include "clocktimesourceinterface.hrh"

// Constants
const TInt KZerothArgument( 0 );
const TInt KFirstArgument( 1 );

// ---------------------------------------------------------
// CClkSrvSession::CClkSrvSession
// rest of the details are commented in the header
// ---------------------------------------------------------
//
CClkSrvSession::CClkSrvSession( CClkSrvImpl* aClkSrvImpl ) : CSession2(), iClkSrvImpl( aClkSrvImpl )
	{
	__PRINTS( "CClkSrvSession::CClkSrvSession - Entry" );
	
	// No implementation yet
	
	__PRINTS( "CClkSrvSession::CClkSrvSession - Exit" );
	}
	
// ---------------------------------------------------------
// CClkSrvSession::~CClkSrvSession
// rest of the details are commented in the header
// ---------------------------------------------------------
//
CClkSrvSession::~CClkSrvSession()
	{
	__PRINTS( "CClkSrvSession::~CClkSrvSession - Entry" );
	
	if( NULL != iSessionLink.iNext )
        {
        iSessionLink.Deque();
        }

	__PRINTS( "CClkSrvSession::~CClkSrvSession - Exit" );
	
	}
	
// ---------------------------------------------------------
// CClkSrvSession::ServiceL
// rest of the details are commented in the header
// ---------------------------------------------------------
//
void CClkSrvSession::ServiceL( const RMessage2& aMessage )
	{
	__PRINTS( "CClkSrvSession::ServiceL - Entry" );
	
	TInt returnValue( KErrNone );
	
	iMessageComplete = ETrue;
	
	// Do the actual service
	TRAPD( error, returnValue = DoServiceL( aMessage ) );
    
    if( iMessageComplete || ( KErrNone > error ) )
    	{
    	// Set the message as completed.
    	aMessage.Complete( ( error == KErrNone ) ? returnValue : error );
    	}
        
    __PRINTS( "CClkSrvSession::ServiceL - Exit" );
	}
	
// ---------------------------------------------------------
// CClkSrvSession::DoServiceL
// rest of the details are commented in the header
// ---------------------------------------------------------
//
TInt CClkSrvSession::DoServiceL( const RMessage2& aMessage )
	{
	__PRINTS( "CClkSrvSession::DoServiceL - Entry" );
	
	TInt returnValue( KErrNone );
	
	// Switch on the type of service request.
	switch( aMessage.Function() )
        {
        case EClkSrvActivateProtocol:
        	{
        	returnValue = DoActivateProtocolL( aMessage );
        	}
            break;
            
        case EClkSrvIsProtocolActive:
        	{
			returnValue = DoCheckProtocolActiveL( aMessage );
        	}
            break;
            
        case EClkSrvDeactivateProtocol:
        	{
        	returnValue = DoDeActivateProtocolL( aMessage );
        	}
            break;
            
        case EClkSrvGetProtocolInfo:
        	{
        	returnValue = DoGetProtocolInfoL( aMessage );
        	}
        	break;
        	
        case EClkSrvGetCurrentMcc:
        	{
        	returnValue = DoGetCurrentMccL( aMessage );
        	}
        	break;
        	
        case EClkSrvGetCurrentTimeZoneId:
        	{
        	returnValue = DoGetCurrentTimeZoneIdL( aMessage );
        	}
        	break;
        	
        case EClkSrvNotifyOnChange:
        	{
        	DoNotifyOnChange( aMessage );
        	}
        	break;
        	
        case EClkSrvCancelNotifyOnChange:
            {
        	NotifyAboutChange( EComponentNone, KErrNone, KErrCancel );
        	}
        	break;
        	
        case EClkSrvIsAutoTimeUpdadeOn:
            {
            returnValue = DoCheckAutoTimeUpdateOn( aMessage );
            }
            break;
        	
		default:
			{
			returnValue = KErrNotSupported;
			}         
			break;
        }
    
	__PRINTS( "CClkSrvSession::DoServiceL - Exit" );
	
	return returnValue;
	}

// ---------------------------------------------------------
// CClkSrvSession::LinkOffset()
// rest of the details are commented in the header
// ---------------------------------------------------------
//	
TInt CClkSrvSession::LinkOffset()
	{
	__PRINTS( "CClkSrvSession::LinkOffset - Entry" );
	
	__PRINTS( "CClkSrvSession::LinkOffset - Exit" );
	
	return _FOFF( CClkSrvSession, iSessionLink );
	}
	
// ---------------------------------------------------------
// CClkSrvSession::DoActivateProtocol()
// rest of the details are commented in the header
// ---------------------------------------------------------
//	
TInt CClkSrvSession::DoActivateProtocolL( const RMessage2& /*aMessage*/ )
	{
	__PRINTS( "CClkSrvSession::DoActivateProtocolL - Entry" );
	
	// Activate all the protocols.
	TInt returnVal = iClkSrvImpl->ActivateAllProtocolsL();
	
	__PRINTS( "CClkSrvSession::DoActivateProtocolL - Exit" );
	
	return returnVal;
	}

// ---------------------------------------------------------
// CClkSrvSession::DoCheckProtocolActive()
// rest of the details are commented in the header
// ---------------------------------------------------------
//	
TInt CClkSrvSession::DoCheckProtocolActiveL( const RMessage2& aMessage )
	{
	__PRINTS( "CClkSrvSession::DoCheckProtocolActiveL - Entry" );
	
	TBool protocolActive( EFalse );
	
	// Check if protocol is active.
	TInt returnVal = iClkSrvImpl->IsProtocolActive( protocolActive, aMessage.Int0() );
	
	if( KErrNone == returnVal )
		{
		TPckgBuf< TBool > packageBuf( protocolActive );
		
		// Return the value.
		aMessage.WriteL( KFirstArgument, packageBuf, NULL );
		}
	
	__PRINTS( "CClkSrvSession::DoCheckProtocolActiveL - Exit" );
	
	return returnVal;
	}

// ---------------------------------------------------------
// CClkSrvSession::DoDeActivateProtocol()
// rest of the details are commented in the header
// ---------------------------------------------------------
//	
TInt CClkSrvSession::DoDeActivateProtocolL( const RMessage2& /*aMessage*/ )
	{
	__PRINTS( "CClkSrvSession::DoDeActivateProtocol - Entry" );
	
	// Deactivate all the protocols.
	TInt returnVal = iClkSrvImpl->DeActivateAllProtocolsL();
	
	__PRINTS( "CClkSrvSession::DoDeActivateProtocol - Exit" );
	
	return returnVal;
	}

// ---------------------------------------------------------
// CClkSrvSession::DoGetProtocolInfoL()
// rest of the details are commented in the header
// ---------------------------------------------------------
//
TInt CClkSrvSession::DoGetProtocolInfoL( const RMessage2& aMessage )
	{
	__PRINTS( "CClkSrvSession::DoGetProtocolInfoL - Entry" );
	
	STimeAttributes timeInformation;
		
	// Ask the implementation for the time information.
	TInt returnVal = iClkSrvImpl->GetProtocolInformationL( timeInformation );

	if( KErrNone == returnVal )
		{
		TPckg< STimeAttributes > packageBuf( timeInformation );

		// Write the result.
		aMessage.WriteL( KFirstArgument, packageBuf, NULL );
		}
	
	__PRINTS( "CClkSrvSession::DoGetProtocolInfoL - Exit" );
	
	return returnVal;
	}

// ---------------------------------------------------------
// CClkSrvSession::DoGetCurrentMccL()
// rest of the details are commented in the header
// ---------------------------------------------------------
//
TInt CClkSrvSession::DoGetCurrentMccL( const RMessage2& aMessage )
	{
	__PRINTS( "CClkSrvSession::DoGetCurrentMccL - Entry" );
	
	TInt currentMcc( 0 ); 
	
	// Ask the implementation for the mcc.
	TInt returnVal = iClkSrvImpl->GetCurrentMccL( currentMcc );
	
	if( KErrNone == returnVal )
		{
		TPckg< TInt > packageBuf( currentMcc );
		
		// Write the result
		aMessage.WriteL( KZerothArgument, packageBuf, NULL );
		}
	
	__PRINTS( "CClkSrvSession::DoGetCurrentMccL - Exit" );
	
	return returnVal;
	}

// ---------------------------------------------------------
// CClkSrvSession::DoGetCurrentMccL()
// rest of the details are commented in the header
// ---------------------------------------------------------
//
TInt CClkSrvSession::DoGetCurrentTimeZoneIdL( const RMessage2& aMessage )
	{
	__PRINTS( "CClkSrvSession::DoGetCurrentTimeZoneIdL - Entry" );
	
	TInt currentTimeZoneId( -1 );
	
	TInt returnVal = iClkSrvImpl->GetCurrentTimeZoneIdL( currentTimeZoneId );
	
	__PRINT( "currentTimeZoneId in DoGetCurrentTimeZoneIdL : %d", currentTimeZoneId );
	
	if( KErrNone == returnVal )
		{
		TPckg< TInt > packageBuf( currentTimeZoneId );
		
		// Write the result
		aMessage.WriteL( KZerothArgument, packageBuf, NULL );
		}
	
	__PRINTS( "CClkSrvSession::DoGetCurrentTimeZoneIdL - Exit" );
	
	return returnVal;
	}

// ---------------------------------------------------------
// CClkSrvSession::DoNotifyOnChange()
// rest of the details are commented in the header
// ---------------------------------------------------------
//	
void CClkSrvSession::DoNotifyOnChange( const RMessage2& aMessage )
	{
	__PRINTS( "CClkSrvSession::DoNotifyOnChange - Entry" );
	
	// First store the message for notification later.
	SetNotifyMessagePtr( aMessage );
	
	if( FirstNotifyRequest() )
        {
        NotifyAboutChange( EComponentNone, 0, KErrNone );
        }
        
    iMessageComplete = EFalse;
	
	__PRINTS( "CClkSrvSession::DoNotifyOnChange - Exit" );
	}

// ---------------------------------------------------------
// CClkSrvSession::DoCheckAutoTimeUpdateOn
// rest of the details are commented in the header
// ---------------------------------------------------------
//  
TInt CClkSrvSession::DoCheckAutoTimeUpdateOn( const RMessage2& aMessage )
    {
    __PRINTS( "CClkSrvSession::DoCheckAutoTimeUpdateOn - Entry" );
        
    TBool autoTimeUpdateOn( EFalse );

    // Check if any protocol is active.
    TInt returnVal = iClkSrvImpl->IsAutoTimeUpdateOn( autoTimeUpdateOn );

    if( KErrNone == returnVal )
        {
        TPckgBuf< TBool > packageBuf( autoTimeUpdateOn );

        // Return the value.
        aMessage.WriteL( KZerothArgument, packageBuf, NULL );
        }

    __PRINTS( "CClkSrvSession::DoCheckAutoTimeUpdateOn - Exit" );

    return returnVal;
    }
	
// ---------------------------------------------------------
// CClkSrvSession::SetNotifyMessagePtr()
// rest of the details are commented in the header
// ---------------------------------------------------------
//
void CClkSrvSession::SetNotifyMessagePtr( const RMessage2& aMessage )
    {
    __PRINTS( "CClkSrvSession::SetNotifyMessagePtr - Entry" );
    
    // __ASSERT_ALWAYS( NotifyPending() == EFalse, PanicClient( aMessage, ENitzMdlNotifyPending ) );
    
    // Store the message for notifying later.
    iNotifyChangeMsg = aMessage;
    
    // Reset the flags.
    iMsgPendingFlags = 0;
    // Change the state to msg pending.
    iMsgPendingFlags |= ENotifyMsgPending;
    
    __PRINTS( "CClkSrvSession::SetNotifyMessagePtr - Exit" );
    }	
	
// ---------------------------------------------------------
// CClkSrvSession::NotifyAboutChange()
// rest of the details are commented in the header
// ---------------------------------------------------------
//
void CClkSrvSession::NotifyAboutChange( TInt32 aWhatChanged, TInt32 aWhoChanged, TInt aNotification )
    {
    __PRINTS( "CClkSrvSession::NotifyAboutChange - Entry" );
    
    if( NotifyPending() )
        {
        __PRINTS( "CClkSrvSession::NotifyAboutChange - Notification was pending" );
        
        // Reset the flags.
        iMsgPendingFlags &= ~( ENotifyMsgPending );
        
        TPckg< TInt32 > whatChangedPkg( aWhatChanged );
        TPckg< TInt32 > whoChangedPkg( aWhoChanged );
        
        // Write the result
        TRAP_IGNORE( iNotifyChangeMsg.WriteL( KZerothArgument, whatChangedPkg ) );
        
        __PRINTS( "CClkSrvSession::NotifyAboutChange - 0th WriteL didn't leave" );
        
        TRAP_IGNORE( iNotifyChangeMsg.WriteL( KFirstArgument, whoChangedPkg ) );
        
        __PRINTS( "CClkSrvSession::NotifyAboutChange - 1st WriteL didn't leave" );
        
        // Mark the message as complete.
        iNotifyChangeMsg.Complete( aNotification );
        }
    
    __PRINTS( "CClkSrvSession::NotifyAboutChange - Notification was not pending" );
    
    __PRINTS( "CClkSrvSession::NotifyAboutChange - Exit" );
    }

// ---------------------------------------------------------
// CClkSrvSession::FirstNotifyRequest()
// rest of the details are commented in the header
// ---------------------------------------------------------
//
TBool CClkSrvSession::FirstNotifyRequest() const
    {
    __PRINTS( "CClkSrvSession::FirstNotifyRequest - Entry" );
    
    __PRINTS( "CClkSrvSession::FirstNotifyRequest - Exit" );
    
    return ( iMsgPendingFlags & EFirstChangeMsg );
    }

// ---------------------------------------------------------
// CClkSrvSession::FirstNotifyRequest()
// rest of the details are commented in the header
// ---------------------------------------------------------
//
TBool CClkSrvSession::NotifyPending() const
    {
    __PRINTS( "CClkSrvSession::NotifyPending - Entry" );
    
    __PRINT( "Notification Pending?: %d", iMsgPendingFlags & ENotifyMsgPending );
    
    __PRINTS( "CClkSrvSession::NotifyPending - Exit" );
    
    return ( iMsgPendingFlags & ENotifyMsgPending );
    }
    	
// End of file