/*

* 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:  Key capture utility

 *

*/

// INCLUDE FILES

#include "lockappkeycapturecontroller.h"

#include <w32std.h>

// ================= STATIC MEMBERS =========================

CLockAppKeyCaptureController* CLockAppKeyCaptureController::instance = NULL;

// ================= STATIC FUNCTIONS =======================

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

// Initializes the key capture utility by creating an instance of it

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

CLockAppKeyCaptureController* CLockAppKeyCaptureController::InitL( RWindowGroup& aWindowGroup )

    {

    if ( !instance )

        {

        instance = new ( ELeave ) CLockAppKeyCaptureController( aWindowGroup );

        }

    return instance;

    }

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

// Destroys the key capture utility's instance

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

void CLockAppKeyCaptureController::Destroy( )

    {

    if ( instance )

        {

        delete instance;

        instance = NULL;

        }

    }

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

// Capture a key

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

void CLockAppKeyCaptureController::CaptureKey( TUint32 aKey, TUint32 aKeyCode, TPhoneKeyCaptureType aType )

    {

    	RDebug::Printf( "%s %s (%u) aKey=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, aKey );

    	RDebug::Printf( "%s %s (%u) aKeyCode=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, aKeyCode );

    	RDebug::Printf( "%s %s (%u) aType=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, aType );

    if ( instance )

        {

        instance->StartCapturingKey( aKey, aKeyCode, aType );

        }

    }

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

// Release a key (previously captured)

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

void CLockAppKeyCaptureController::ReleaseKey( TUint32 aKey )

    {

    	RDebug::Printf( "%s %s (%u) aKey=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, aKey );

    if ( instance )

        {

        instance->StopCapturingKey( aKey );

        }

    }

// ================= INSTANCE FUNCTIONS ============================

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

// Private default constructor

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

CLockAppKeyCaptureController::CLockAppKeyCaptureController( RWindowGroup& aWindowGroup ) :

    iWindowGroup( aWindowGroup)

    {

    }

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

// Private destructor

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

CLockAppKeyCaptureController::~CLockAppKeyCaptureController( )

    {

    	RDebug::Printf( "%s %s (%u) value=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, 0 );

    // should we have any captured keys, stop capturing now

    TInt capturedKeyCount = iCapturedKeys.Count( );

    for (TInt i = 0; i < capturedKeyCount; i++ )

        {

        StopKeyCapture( iCapturedKeys[i] );

        }

    iCapturedKeys.Close( );

    }

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

// Starts capturing a key

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

void CLockAppKeyCaptureController::StartCapturingKey( TUint32 aKey, TUint32 aKeyCode, TPhoneKeyCaptureType aType )

    {

    TInt32 handle = KErrNotFound;

		RDebug::Printf( "%s %s (%u) aKey=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, aKey );

		RDebug::Printf( "%s %s (%u) aKeyCode=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, aKeyCode );

		RDebug::Printf( "%s %s (%u) aType=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, aType );

    if ( !IsKeyCaptured( aKey ) )

        {

        TPhoneKeyCapture keyCapture;

        keyCapture.iKey = (TStdScanCode) aKey;

        keyCapture.iKeyCode = (TKeyCode) aKeyCode;

        keyCapture.iHandle = 0; // set as initial value

        keyCapture.iHandleForUpAndDown = 0; // set as initial value

        switch( aType )

            {

            case EKeyCaptureEvent:

                keyCapture.iType = EKeyCaptureEvent;

                keyCapture.iHandle = iWindowGroup.CaptureKey( keyCapture.iKeyCode, 0, 0 );

                handle = keyCapture.iHandle;

                break;

            case EKeyCaptureUpAndDownEvents:

                keyCapture.iType = EKeyCaptureUpAndDownEvents;

                keyCapture.iHandleForUpAndDown = iWindowGroup.CaptureKeyUpAndDowns( keyCapture.iKey, 0, 0 );

                handle = keyCapture.iHandleForUpAndDown;

                break;

            default: // EKeyCaptureAllEvents

                {

                keyCapture.iType = EKeyCaptureAllEvents;

                keyCapture.iHandle = iWindowGroup.CaptureKey( keyCapture.iKeyCode, 0, 0 );

                if ( keyCapture.iHandle >= 0 )

                    {

                    keyCapture.iHandleForUpAndDown = iWindowGroup.CaptureKeyUpAndDowns( keyCapture.iKey, 0, 0 );

                    if ( keyCapture.iHandleForUpAndDown < 0 )

                        {

                        iWindowGroup.CancelCaptureKey( keyCapture.iHandle );

                        }

                    handle = keyCapture.iHandleForUpAndDown;

                    }

                break;

                }

            }

        RDebug::Printf( "CLockAppKeyCaptureController::StartCapturingKey - handle: 0x%08x", handle );

        if ( handle >= 0 )

            {

            if ( iCapturedKeys.Append( keyCapture )!= KErrNone )

                {

                StopKeyCapture( keyCapture );

                }

            }

        }

    }

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

// Stops capturing a key

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

void CLockAppKeyCaptureController::StopCapturingKey( TUint32 aKey )

    {

		RDebug::Printf( "%s %s (%u) aKey=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, aKey );

    const TInt capturedKeyCount = iCapturedKeys.Count( );

    TBool foundKey = EFalse;

    for (TInt i = 0; ( i < capturedKeyCount ) && !foundKey; i++ )

        {

        if ( iCapturedKeys[i].iKey == aKey )

            {

            foundKey = ETrue;

            StopKeyCapture( iCapturedKeys[i] );

            iCapturedKeys.Remove( i );

            }

        }

    }

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

// May be used to ask whether a key has been set to be captured

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

TBool CLockAppKeyCaptureController::IsKeyCaptured( TUint32 aKey ) const

    {

		RDebug::Printf( "%s %s (%u) aKey=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, aKey );

    const TInt capturedKeyCount = iCapturedKeys.Count( );

    TBool isCaptured = EFalse;

    for (TInt i = 0; ( i < capturedKeyCount ) && !isCaptured; i++ )

        {

        isCaptured = iCapturedKeys[i].iKey == aKey;

        }

    return isCaptured;

    }

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

// Stops capturing a key

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

void CLockAppKeyCaptureController::StopKeyCapture( TPhoneKeyCapture aKeyCapture )

    {

		RDebug::Printf( "%s %s (%u) value=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, 0 );

    switch ( aKeyCapture.iType )

        {

        case EKeyCaptureEvent:

            iWindowGroup.CancelCaptureKey( aKeyCapture.iHandle );

            break;

        case EKeyCaptureUpAndDownEvents:

            iWindowGroup.CancelCaptureKeyUpAndDowns( aKeyCapture.iHandleForUpAndDown );

            break;

        default: // EPhoneKeyCaptureAllEvents

            {

            iWindowGroup.CancelCaptureKey( aKeyCapture.iHandle );

            iWindowGroup.CancelCaptureKeyUpAndDowns( aKeyCapture.iHandleForUpAndDown );

            break;

            }

        }

    }

// end of file