/*
* Copyright (c) 2002 - 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:  Test AknKeyLock.h
*
*/

    
    
// [INCLUDE FILES]
#include <e32svr.h>
#include <stifparser.h>
#include <stiftestinterface.h>
#include <aknkeylock.h>

#include "testsdkkeylock.h"
// ============================ MEMBER FUNCTIONS ===============================
    
// -----------------------------------------------------------------------------
// CTestSDKKeyLock::Delete
// Delete here all resources allocated and opened from test methods. 
// Called from destructor. 
// -----------------------------------------------------------------------------
//
void CTestSDKKeyLock::Delete() 
    {
    
    }
    
// -----------------------------------------------------------------------------
// CTestSDKKeyLock::RunMethodL
// Run specified method. Contains also table of test mothods and their names.
// -----------------------------------------------------------------------------
//
TInt CTestSDKKeyLock::RunMethodL( CStifItemParser& aItem ) 
    {
    static TStifFunctionInfo const KFunctions[] =
        {
        ENTRY( "TestKLConnectL", CTestSDKKeyLock::TestKLConnectL ),
        ENTRY( "TestKLEnableKeyLockL", CTestSDKKeyLock::TestKLEnableKeyLockL ),
        ENTRY( "TestKLDisableKeyLockL", CTestSDKKeyLock::TestKLDisableKeyLockL ),
        ENTRY( "TestKLIsKeyLockEnabledL", CTestSDKKeyLock::TestKLIsKeyLockEnabledL ),
        ENTRY( "TestKLEnableSoftNotificationsL", CTestSDKKeyLock::TestKLEnableSoftNotificationsL ),
        ENTRY( "TestKLOfferKeyLockL", CTestSDKKeyLock::TestKLOfferKeyLockL ),
        ENTRY( "TestKLCancelAllNotificationsL", CTestSDKKeyLock::TestKLCancelAllNotificationsL ),
        ENTRY( "TestKLDisableWithoutNoteL", CTestSDKKeyLock::TestKLDisableWithoutNoteL ),
        ENTRY( "TestKLEnableWithoutNoteL", CTestSDKKeyLock::TestKLEnableWithoutNoteL ),
        ENTRY( "TestKLEnableAutoLockEmulationL", CTestSDKKeyLock::TestKLEnableAutoLockEmulationL ),
        };
    
    const TInt count = sizeof( KFunctions ) / sizeof( TStifFunctionInfo );
    
    return RunInternalL( KFunctions, count, aItem );
    
    }

// ============================ MEMBER FUNCTIONS ===============================

// =========================== CLASS RAKNKEYLOCK2 ==============================
// -----------------------------------------------------------------------------
// CTestSDKKeyLock::TestKLConnectL
// -----------------------------------------------------------------------------
TInt CTestSDKKeyLock::TestKLConnectL( CStifItemParser& /*aItem*/ )
    {
    RAknKeyLock connect;
    CleanupClosePushL( connect );
    STIF_ASSERT_EQUALS( KErrNone, connect.Connect() );
    
    STIF_ASSERT_NOT_NULL( &connect );
    
    connect.EnableKeyLock();
    STIF_ASSERT_TRUE( connect.IsKeyLockEnabled() );
    connect.DisableKeyLock();
    STIF_ASSERT_FALSE( connect.IsKeyLockEnabled() );
    
    CleanupStack::PopAndDestroy( &connect );
    
    return KErrNone;
    }

// =========================== CLASS RAKNKEYLOCK ===============================
// -----------------------------------------------------------------------------
// CTestSDKKeyLock::TestKLEnableKeyLockL 
// -----------------------------------------------------------------------------
TInt CTestSDKKeyLock::TestKLEnableKeyLockL( CStifItemParser& /*aItem*/ )
    {
    RAknKeyLock enablekeylock;
    CleanupClosePushL( enablekeylock );
    STIF_ASSERT_NOT_LEAVES( enablekeylock.Connect() );
    
    STIF_ASSERT_NOT_NULL( &enablekeylock );
    
    STIF_ASSERT_FALSE( enablekeylock.IsKeyLockEnabled() );
    enablekeylock.EnableKeyLock();
    STIF_ASSERT_TRUE( enablekeylock.IsKeyLockEnabled() );
    enablekeylock.DisableKeyLock();
    STIF_ASSERT_FALSE( enablekeylock.IsKeyLockEnabled() );
    
    CleanupStack::PopAndDestroy( &enablekeylock );
    
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CTestSDKKeyLock::TestKLDisableKeyLockL
// -----------------------------------------------------------------------------
TInt CTestSDKKeyLock::TestKLDisableKeyLockL( CStifItemParser& /*aItem*/ )
    {
    RAknKeyLock disablekeylock;
    CleanupClosePushL( disablekeylock );
    STIF_ASSERT_NOT_LEAVES( disablekeylock.Connect() );
    
    STIF_ASSERT_NOT_NULL( &disablekeylock );
    
    STIF_ASSERT_FALSE( disablekeylock.IsKeyLockEnabled() );
    disablekeylock.EnableKeyLock();
    STIF_ASSERT_TRUE( disablekeylock.IsKeyLockEnabled() );
    disablekeylock.DisableKeyLock();
    STIF_ASSERT_FALSE( disablekeylock.IsKeyLockEnabled() );
    
    CleanupStack::PopAndDestroy( &disablekeylock );
    
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CTestSDKKeyLock::TestKLIsKeyLockEnabledL
// -----------------------------------------------------------------------------
TInt CTestSDKKeyLock::TestKLIsKeyLockEnabledL( CStifItemParser& /*aItem*/ )
    {
    RAknKeyLock iskeylockenabled;
    CleanupClosePushL( iskeylockenabled );
    STIF_ASSERT_NOT_LEAVES( iskeylockenabled.Connect() );
    
    STIF_ASSERT_NOT_NULL( &iskeylockenabled );
    
    STIF_ASSERT_FALSE( iskeylockenabled.IsKeyLockEnabled() );
    iskeylockenabled.EnableKeyLock();
    STIF_ASSERT_TRUE( iskeylockenabled.IsKeyLockEnabled() );
    iskeylockenabled.DisableKeyLock();
    STIF_ASSERT_FALSE( iskeylockenabled.IsKeyLockEnabled() );
    
    CleanupStack::PopAndDestroy( &iskeylockenabled );
    
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CTestSDKKeyLock::TestKLEnableSoftNotificationsL
// -----------------------------------------------------------------------------
TInt CTestSDKKeyLock::TestKLEnableSoftNotificationsL( CStifItemParser& /*aItem*/ )
    {
    RAknKeyLock enablesoftnotifications;
    CleanupClosePushL( enablesoftnotifications );
    STIF_ASSERT_NOT_LEAVES( enablesoftnotifications.Connect() );
    
    STIF_ASSERT_NOT_NULL( &enablesoftnotifications );
    
    enablesoftnotifications.EnableKeyLock();
    STIF_ASSERT_TRUE( enablesoftnotifications.IsKeyLockEnabled() );
    
    TBool enable = EFalse;
    enablesoftnotifications.EnableSoftNotifications( enable );
    
    enablesoftnotifications.DisableKeyLock();
    STIF_ASSERT_FALSE( enablesoftnotifications.IsKeyLockEnabled() );
    
    CleanupStack::PopAndDestroy( &enablesoftnotifications );
    
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CTestSDKKeyLock::TestKLOfferKeyLockL
// -----------------------------------------------------------------------------
TInt CTestSDKKeyLock::TestKLOfferKeyLockL( CStifItemParser& /*aItem*/ )
    {
    RAknKeyLock offerkeylock;
    CleanupClosePushL( offerkeylock );
    STIF_ASSERT_NOT_LEAVES( offerkeylock.Connect() );
    
    STIF_ASSERT_NOT_NULL( &offerkeylock );
    
    offerkeylock.EnableKeyLock();
    STIF_ASSERT_TRUE( offerkeylock.IsKeyLockEnabled() );
    
    offerkeylock.OfferKeyLock();
    
    offerkeylock.DisableKeyLock();
    STIF_ASSERT_FALSE( offerkeylock.IsKeyLockEnabled() );
   
    CleanupStack::PopAndDestroy( &offerkeylock );
    
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CTestSDKKeyLock::TestKLCancelAllNotificationsL
// -----------------------------------------------------------------------------
TInt CTestSDKKeyLock::TestKLCancelAllNotificationsL( CStifItemParser& /*aItem*/ )
    {
    RAknKeyLock cancelallnotifications;
    CleanupClosePushL( cancelallnotifications );
    STIF_ASSERT_NOT_LEAVES( cancelallnotifications.Connect() );
    
    STIF_ASSERT_NOT_NULL( &cancelallnotifications );
    
    cancelallnotifications.EnableKeyLock();
    STIF_ASSERT_TRUE( cancelallnotifications.IsKeyLockEnabled() );
    
    TBool enable = ETrue;
    cancelallnotifications.EnableSoftNotifications( enable );
    
    cancelallnotifications.CancelAllNotifications();
    
    cancelallnotifications.DisableKeyLock();
    STIF_ASSERT_FALSE( cancelallnotifications.IsKeyLockEnabled() );
    
    CleanupStack::PopAndDestroy( &cancelallnotifications );
    
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CTestSDKKeyLock::TestKLEnableWithoutNoteL
// -----------------------------------------------------------------------------
TInt CTestSDKKeyLock::TestKLEnableWithoutNoteL( CStifItemParser& /*aItem*/ )
    {
    RAknKeyLock enablewithoutnote;
    CleanupClosePushL( enablewithoutnote );
    STIF_ASSERT_NOT_LEAVES( enablewithoutnote.Connect() );
    
    STIF_ASSERT_NOT_NULL( &enablewithoutnote );
    
    enablewithoutnote.EnableWithoutNote();
    STIF_ASSERT_TRUE( enablewithoutnote.IsKeyLockEnabled() );
    
    enablewithoutnote.DisableWithoutNote();
    STIF_ASSERT_FALSE( enablewithoutnote.IsKeyLockEnabled() );
    
    CleanupStack::PopAndDestroy( &enablewithoutnote );
    
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CTestSDKKeyLock::TestKLDisableWithoutNoteL
// -----------------------------------------------------------------------------
TInt CTestSDKKeyLock::TestKLDisableWithoutNoteL( CStifItemParser& /*aItem*/ )
    {
    RAknKeyLock disablewithoutnote;
    CleanupClosePushL( disablewithoutnote );
    STIF_ASSERT_NOT_LEAVES( disablewithoutnote.Connect() );
    
    STIF_ASSERT_NOT_NULL( &disablewithoutnote );
    
    disablewithoutnote.EnableWithoutNote();
    STIF_ASSERT_TRUE( disablewithoutnote.IsKeyLockEnabled() );
    
    disablewithoutnote.DisableWithoutNote();
    STIF_ASSERT_FALSE( disablewithoutnote.IsKeyLockEnabled() );
    
    CleanupStack::PopAndDestroy( &disablewithoutnote );
    
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CTestSDKKeyLock::TestKLEnableAutoLockEmulationL
// -----------------------------------------------------------------------------
TInt CTestSDKKeyLock::TestKLEnableAutoLockEmulationL( CStifItemParser& /*aItem*/ )
    {
    RAknKeyLock enableautolockemulation;
    CleanupClosePushL( enableautolockemulation );
    STIF_ASSERT_NOT_LEAVES( enableautolockemulation.Connect() );
    
    STIF_ASSERT_NOT_NULL( &enableautolockemulation );
    
    enableautolockemulation.EnableAutoLockEmulation();
    enableautolockemulation.EnableSoftNotifications( EFalse );

    CleanupStack::PopAndDestroy( &enableautolockemulation );
    
    return KErrNone;
    }