/*

* Copyright (c) 2007-2010 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:  PSM Server session

*

*/

#include <e32property.h>

#include <connect/sbdefs.h>

#include <psmsettingsprovider.h>

#include "psmmanager.h"

#include "psmsrvserver.h"

#include "psmsrvsession.h"

#include "psmsrvmessage.h"

#include "psmclientserver.h"

#include "psmtrace.h"

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

// CPsmSession::NewL

// Two-phased constructor.

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

//

CPsmSession* CPsmSession::NewL( CPsmManager& aPsmManager, CPsmSrvServer& aServer )

    {

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSession::NewL()" ) ) );

    CPsmSession* self = CPsmSession::NewLC( aPsmManager, aServer );

    CleanupStack::Pop( self );

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSession::NewL - return 0x%x" ), self ) );

    return self;

    }

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

// CPsmSession::NewLC

// Two-phased constructor.

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

//

CPsmSession* CPsmSession::NewLC( CPsmManager& aPsmManager, CPsmSrvServer& aServer )

    {

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSession::NewLC()" ) ) );

    CPsmSession* self = new( ELeave ) CPsmSession( aPsmManager, aServer );

    CleanupStack::PushL( self );

    self->ConstructL();

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSession::NewLC - return 0x%x" ), self ) );

    return self;

    }

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

// CPsmSession::CPsmSession

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CPsmSession::CPsmSession( CPsmManager& aPsmManager, CPsmSrvServer& aServer ) :

    iPsmServer( aServer ),

    iPsmManager( aPsmManager )

    {

    // Nothing to do

    }

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

// CPsmSession::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CPsmSession::ConstructL()

    {

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSession::ConstructL()" ) ) );

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSession::ConstructL - return" ) ) );

    }

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

// Destructor

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

//

CPsmSession::~CPsmSession()

    {

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSession::~CPsmSession()" ) ) );

    // Notify server that session is closed

    iPsmServer.SessionClosed();

    // Complete notify message if it is not null

    if ( iNotifyModeMessage )

        {

        iNotifyModeMessage->Complete( KErrCancel );

        // Unregister observer from manager

        iPsmManager.UnregisterObserver( iNotifyModeMessage );

        // Finally delete message

        delete iNotifyModeMessage;

        }

    else

        {

        COMPONENT_TRACE( ( _L( "PSM Server - CPsmSession::~CPsmSession - No pending requests") ) );

        }

    // Reset and close config array

    iConfigArray.Reset();

    iConfigArray.Close();

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSession::~CPsmSession - return") ) );

    }

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

// CPsmSession::ServiceL

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

//

void CPsmSession::ServiceL( const RMessage2& aMessage )

    {

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSession::ServiceL()" ) ) );

    TRAPD( error, DispatchL( aMessage ) );

    // Complete message with error code if there were errors

    if ( KErrNone != error )

        {

        COMPONENT_TRACE( ( _L( "PSM Server - CPsmSession::ServiceL() - Error: %i" ), error ) );

        aMessage.Complete( error );

        }

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSession::ServiceL - return" ) ) );

    }

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

// CPsmSession::DispatchL

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

//

void CPsmSession::DispatchL( const RMessage2& aMessage )

    {

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSession::DispatchL()" ) ) );

    switch ( aMessage.Function() )

        {

        case EPsmServerNotifyModeChange: // For power save mode change

            {

            TInt mode = aMessage.Int0();

            if ( !iNotifyModeMessage )

                {

                // Create message wrapper if not yet created

                iNotifyModeMessage = CPsmMessage::NewL( iPsmManager );

                iPsmManager.RegisterObserver( iNotifyModeMessage );

                }

            // Check that mode to be set is valid, otherwise error code.

            if( mode == iPsmManager.SettingsProvider().Mode() )

                {

                User::Leave( KErrAlreadyExists );

                }

            if( ( mode > EPsmsrvPartialMode ) || ( mode < EPsmsrvModeNormal ) )

                {

                User::Leave( KErrArgument );

                }

            TInt keyVal = -1;

            User::LeaveIfError( RProperty::Get( KUidSystemCategory, conn::KUidBackupRestoreKey, keyVal ) );

			//if backup or restore is in progress, change in power save mode

			//is not allowed as it will not be possible to do write

			//operation in cenrep and it would leave the device in unstable power saving mode state

            if( (( keyVal & conn::KBURPartTypeMask ) != conn::EBURNormal ) 

				&& (( keyVal & conn::KBURPartTypeMask ) != conn::EBURUnset ))

				{

				User::Leave( KErrNotSupported );

				}

            iNotifyModeMessage->Initialize( aMessage );

            iPsmManager.NotifyPowerSaveModeChangeL( mode );

            break;

            }

        case EPsmServerChangeSettings: // For PSM settings

        case EPsmServerGetSettings: // For PSM settings

        case EPsmServerBackupSettings: // For PSM settings

            {

            // Check previous config

            if ( iConfigArray.Count() > 0 )

                {

                iConfigArray.Reset();

                }

            // Handle settings requests in different function

            HandleSettingsRequestL( aMessage );

            break;

            }

        case EPsmServerCancelModeChange: // For cancelling PSM change

            {

            // Cancel PSM change and return previous mode

            if ( iNotifyModeMessage )

                {

                // Unregister observer from manager

                iPsmManager.UnregisterObserver( iNotifyModeMessage );

                // Cancel pending message

                iNotifyModeMessage->Complete( KErrCancel );

                // Finally delete message

                delete iNotifyModeMessage;

                iNotifyModeMessage = NULL;

                }

            // Call PsmManager to stop mode change and to go back to previous

            iPsmManager.CancelPowerSaveModeChangeL();

            // Complete message

            aMessage.Complete( KErrNone );

            break;

            }

        case EPsmServerModeChangeNotificationRequest: // PSM Change notification request

            {

            if ( !iNotifyModeMessage )

                {

                // Create message wrapper if not yet created

                iNotifyModeMessage = CPsmMessage::NewL( iPsmManager );

                iPsmManager.RegisterObserver( iNotifyModeMessage );

                }

            iNotifyModeMessage->Initialize( aMessage );

            break;

            }

        case EPsmServerCancelModeChangeNotificationRequest: // For cancelling PSM change notification

            {

            // Cancel PSM change notification request

            if ( iNotifyModeMessage )

                {

                // Unregister observer from manager

                iPsmManager.UnregisterObserver( iNotifyModeMessage );

                // Cancel pending message

                iNotifyModeMessage->Complete( KErrCancel );

                // Finally delete message

                delete iNotifyModeMessage;

                iNotifyModeMessage = NULL;

                }

            // Complete message

            aMessage.Complete( KErrNone );

            break;

            }

        default:

            {

            COMPONENT_TRACE( ( _L( "PSM Server - CPsmSession::ServiceL() - unknown request: %i - ERROR" ), aMessage.Function() ) );

            User::Leave( KErrUnknown );

            }

        }

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSession::DispatchL - return" ) ) );

    }

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

// CPsmSession::HandleSettingsRequestL

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

//

void CPsmSession::HandleSettingsRequestL( const RMessage2& aMessage )

    {

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSession::HandleSettingsRequestL()" ) ) );

    // read config array from message

    ReadConfigArrayL( iConfigArray, aMessage );

    // Get storage UID

    TUint32 storage = aMessage.Int2();

    TInt err( KErrNone );

    if ( aMessage.Function() == EPsmServerBackupSettings )

        {

        iPsmManager.SettingsProvider().BackupSettingsL( iConfigArray, storage );

        }

    else 

        {

        if ( aMessage.Function() == EPsmServerGetSettings )

            {

            iPsmManager.SettingsProvider().GetSettingsL( iConfigArray, storage );

            }

        else

            {

            // EPsmServerChangeSettings

            iPsmManager.SettingsProvider().BackupAndGetSettingsL( iConfigArray, storage );

            }

        // We have to write changed values back to message

        TInt arraySize( iConfigArray.Count() * sizeof( TPsmsrvConfigInfo ) );

        TPtr8 arrayPtr( reinterpret_cast<TUint8*>(&iConfigArray[0]), arraySize, arraySize );

        err = aMessage.Write( 0, arrayPtr );

        ERROR_TRACE( ( _L( "PSM Server - CPsmSession::HandleSettingsRequestL - New data wrote to message: %i" ), err ) );

        }

    // Complete message before destroying local config array

    aMessage.Complete( err );

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSession::HandleSettingsRequestL - return" ) ) );

    }

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

// CPsmSession::ReadConfigArrayL

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

//

void CPsmSession::ReadConfigArrayL( RConfigInfoArray& aArray, const RMessage2& aMessage )

    {

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSession::ReadConfigArrayL()" ) ) );

    const TInt configCount( aMessage.Int1() );

    TInt arrayLength( configCount * sizeof( TPsmsrvConfigInfo ) );

    // There is no ResizeL() for RArray

    // ReserveL() does not change iCount, which will

    // result array[0] failure (access beyond array index)

    // That is why we fill the array with dummy items

    for(TInt x = 0; x < configCount; ++x )

    	{

        // Append empty config infos to array

    	aArray.AppendL( TPsmsrvConfigInfo() );

    	}

    TPtr8 arrayPtr( ( TUint8* )&aArray[0], arrayLength, arrayLength );

    aMessage.ReadL( 0, arrayPtr, 0 );

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSession::ReadConfigArrayL - return" ) ) );

    }

// End of file