/*
* Copyright (c) 2007 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:  LockApp server session requested by lockclient
 *
*/


#include "lockapptrace.h"
#include "lockappsession.h"
#include "lockappappui.h"
#include "lockappstatecontrolinterface.h"
#include "lockapputils.h"
#include <lockappclientserver.h>

// ---------------------------------------------------------------------------
// Default Constructor.
// ---------------------------------------------------------------------------
CLockAppSession::CLockAppSession( )
    {

    // no implementation required
    }

// ---------------------------------------------------------------------------
// Default Destructor.
// ---------------------------------------------------------------------------
CLockAppSession::~CLockAppSession( )
    {
    // no implementation required
    }

// ---------------------------------------------------------------------------
// From @c CApaAppServiceBase. Handles possible error in the lock app session
// Method is empty.
// ---------------------------------------------------------------------------
void CLockAppSession::ServiceError( const RMessage2& aMessage, TInt aError )
    {

    if ( aError == KErrNotReady )
        {
        // initialization not yet ready
        aMessage.Complete( KErrNotReady );
        ERROR( aError, "LockApp initialization not yet ready, KErrNotReady" );
        }
    else
        {
        ERROR_1( aError, "Service request has caused a leave, message: %d", aMessage.Function());
        CApaAppServiceBase::ServiceError( aMessage, aError );
#ifdef _DEBUG
        if ( aMessage.Function( )== ELockAppTestDestruct )
            {
            User::Leave( KErrGeneral );
            }
#endif
        }
    }

// ---------------------------------------------------------------------------
// From @c CApaAppServiceBase. Handles a client request. Leaving is handled by
// CLockAppSession::ServiceError() which reports the error code to the client
// ---------------------------------------------------------------------------
void CLockAppSession::ServiceL(const RMessage2& aMessage )
    {  
		RThread clientThread;
		TInt err=aMessage.Client(clientThread);
		// RDebug::Print( _L("called by %S"), &(clientThread.FullName()) );
		// RDebug::Print( clientThread.FullName() );

    TInt response = KErrNone;
    // log the message
    // whole provided server API is implemented here

    switch ( aMessage.Function( ) )
        {
        case ELockAppEnableKeyguard:
            // enable with or without note (depends on first parameter)
            response = DoEnableKeyguardL( aMessage.Int0() );
            break;
        case ELockAppDisableKeyguard:
            // disable with or without note (depends on first parameter)
            response = DoDisableKeyguardL( aMessage.Int0() );
            break;
        case ELockAppEnableDevicelock:
            // check that client has needed capabilities to enable devicelock
            if ( aMessage.HasCapability( ECapabilityWriteDeviceData ) )
                {
                // first parameter contains the reason
                response = DoEnableDevicelockL( (TDevicelockReason) aMessage.Int0() );
                }
            else
                {
                response = KErrPermissionDenied;
                }
            break;
        case ELockAppDisableDevicelock:
            // check that client has needed capabilities to disable devicelock
            if ( aMessage.HasCapability( ECapabilityWriteDeviceData ) )
                {
                response = DoDisableDevicelockL( );
                }
            else
                {
                response = KErrPermissionDenied;
                }
            break;
        case ELockAppOfferKeyguard:
            // offer to lock keyguard
            response = DoOfferKeyguardL( );
            break;
        case ELockAppOfferDevicelock:
            // TODO implement this someday if needed
            response = KErrNotSupported;
            break;
        case ELockAppShowKeysLockedNote:
            response = DoShowKeysLockedNoteL( );
            break;
#ifdef _DEBUG
        case ELockAppTestDestruct:
            // test for leave
            User::Leave( KErrGeneral );
            break;
        case ELockAppTestInternal:
            // test internal functions (which cannot be tested trough client API)
            response = StateControlL()->ExecuteInternalTest( );
            break;
#endif
        default:
            // illegal message call, panic the client process
            PanicClient( aMessage, ELockPanicIllegalMessage );
            return;
        }

    INFO_2( "CLockAppSession received service message: %d. Result: %d", aMessage.Function(), response );
    aMessage.Complete( response );
    }

// ---------------------------------------------------------------------------
// Request lockapp to enable keyguard on device (might not be approved, e.g.
// devicelock activated).
// ---------------------------------------------------------------------------
TInt CLockAppSession::DoEnableKeyguardL( TBool aShowNote )
    {
    // calls the main control

    return StateControlL()->EnableKeyguardL( aShowNote );
    }

// ---------------------------------------------------------------------------
// Request lockapp to disable keyguard on device (might not be approved, e.g.
// already disabled).
// ---------------------------------------------------------------------------
TInt CLockAppSession::DoDisableKeyguardL( TBool aShowNote )
    {
    // calls the main control

    return StateControlL()->DisableKeyguardL( aShowNote );
    }

// ---------------------------------------------------------------------------
// Request lockapp to enable devicelock on device (might not be approved).
// ---------------------------------------------------------------------------
TInt CLockAppSession::DoEnableDevicelockL( TDevicelockReason aReason )
    {
    // calls the main control

    return StateControlL()->EnableDevicelockL( aReason );
    }

// ---------------------------------------------------------------------------
// Request lockapp to disable devicelock on device (might not be approved).
// ---------------------------------------------------------------------------
TInt CLockAppSession::DoDisableDevicelockL( )
    {
    // TODO Investigate if this should be allowed in API or not
    // calls the main control
    // StateControlL()->DisableDevicelockL( );
    return KErrPermissionDenied;
    }

// ---------------------------------------------------------------------------
// Request to offer keyguard on device (might not be approved, e.g.
// already locked).
// ---------------------------------------------------------------------------
TInt CLockAppSession::DoOfferKeyguardL( )
    {
    // calls the main control
    return StateControlL()->OfferKeyguard( );
    }

// ---------------------------------------------------------------------------
// Request to show keys locked note, only works if keyguard is enabled
// ---------------------------------------------------------------------------
TInt CLockAppSession::DoShowKeysLockedNoteL( )
    {
    // calls the main control

    return StateControlL()->ShowKeysLockedNote( );
    }

// ---------------------------------------------------------------------------
// Return the main state control to the server session.
// Application appui and the main state control might not be constructed yet.
// ---------------------------------------------------------------------------
MLockAppStateControl* CLockAppSession::StateControlL( )
    {

    // other parts of lockapp construction may not be finished
    if ( !iStateControl )
        {
        CLockAppAppUi* appUi = (CLockAppAppUi*) CEikonEnv::Static()->EikAppUi();
        if ( appUi )
            {
            iStateControl = appUi->StateControl( );
            if ( !iStateControl )
                {
                User::Leave( KErrNotReady );
                }
            }
        else
            {
            User::Leave( KErrNotReady );
            }
        }
    return iStateControl;
    }