/*

* 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:  Devicelock UI

 *

*/

#include "lockappdevicelockcontrol.h"

#include "lockappdevicelockcontainer.h"

#include "lockappstatecontrolinterface.h"

#include "lockapppubsubobserver.h"

#include "lockappcenrepobserver.h"

#include "lockapputils.h"

#include "lockappwait.h"

#include "lockappkeycapturecontroller.h"

#include <lockapp.rsg> // general avkon resources

#include <avkon.rsg> // general avkon resources

#include <aknnotpi.rsg> // keyguard spesific resources

#include <AknUtils.h>

#include <akntitle.h> // CAknTitlePane

#include <activitymanager.h>

#include <e32property.h>

#include <etelmm.h>

#include <mmtsy_names.h>

#include <featmgr.h>

#include <secui.h>

#include <secuisecurityhandler.h>

#include <settingsinternalcrkeys.h>  // KSettingsAutolockStatus

#include <coreapplicationuisdomainpskeys.h>

#include <securityuisprivatepskeys.h>

#include <startupdomainpskeys.h>

#include <startupdomaincrkeys.h>

#include <ctsydomainpskeys.h>

#ifdef __SAP_TERMINAL_CONTROL_FW

#include <SCPClient.h>

#endif // __SAP_TERMINAL_CONTROL_FW

const TInt KAutoDeviceLockOff( 60000 );

const TInt KPhoneIndex( 0 );

const TInt KTriesToConnectServer( 2 );

const TInt KTimeBeforeRetryingServerConnection( 50000 );

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

// Standard Symbian OS construction sequence

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

CLockAppDevicelockControl* CLockAppDevicelockControl::NewL(MLockAppStateControl& aStateControl, RWindowGroup& aWg )

    {

    CLockAppDevicelockControl* self = new (ELeave) CLockAppDevicelockControl( aStateControl );

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

    CleanupStack::PushL( self );

    self->ConstructL( aWg );

    CleanupStack::Pop( self );

    return self;

    }

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

// Constructor passes the reference to the main state control.

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

CLockAppDevicelockControl::CLockAppDevicelockControl(MLockAppStateControl& aStateControl) :

    CLockAppBaseControl(aStateControl), iShowingSecCodeQuery(EFalse)

    {

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

    }

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

// Destructor.

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

CLockAppDevicelockControl::~CLockAppDevicelockControl( )

    {

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

    /*****************************************************

    *    S60 Customer / ETel

    *    S60  ETel API

    *****************************************************/

    /*****************************************************

    *    S60 Customer / TSY

    *    Needs customer TSY implementation

    *****************************************************/

    RDebug::Printf( "%s %s (%u) iCustomPhoneInitialized=%x -> -1 ", __FILE__, __PRETTY_FUNCTION__, __LINE__, iCustomPhoneInitialized );

    iCustomPhoneInitialized=-1;

    if ( iCustomPhone.SubSessionHandle( ) )

        {

        iCustomPhone.Close( );

        RDebug::Printf( "%s %s (%u) iCustomPhoneInitialized=%x -> -2 ", __FILE__, __PRETTY_FUNCTION__, __LINE__, iCustomPhoneInitialized );

        iCustomPhoneInitialized=-2;

        }

		RDebug::Printf( "%s %s (%u) iPhoneInitialized=%x -> -1 ", __FILE__, __PRETTY_FUNCTION__, __LINE__, iPhoneInitialized );

		iPhoneInitialized=-1;

    if ( iPhone.SubSessionHandle( ) )

        {

        iPhone.Close( );

        RDebug::Printf( "%s %s (%u) iPhoneInitialized=%x -> -2 ", __FILE__, __PRETTY_FUNCTION__, __LINE__, iPhoneInitialized );

				iPhoneInitialized=-2;

        }

    RDebug::Printf( "%s %s (%u) iTelServerInitialized=%x -> -1 ", __FILE__, __PRETTY_FUNCTION__, __LINE__, iTelServerInitialized );

    iTelServerInitialized=-1;

    if ( iTelServer.Handle( ) )

        {

        iTelServer.UnloadPhoneModule( KMmTsyModuleName );

        iTelServer.Close( );

        RDebug::Printf( "%s %s (%u) iTelServerInitialized=%x -> -2 ", __FILE__, __PRETTY_FUNCTION__, __LINE__, iTelServerInitialized );

        iTelServerInitialized=-2;

        }

    if ( iActivityManager )

        {

        iActivityManager->Cancel( );

        delete iActivityManager;

        iActivityManager = NULL;

        }

    // CenRep observers

    if ( iCRAutoLockTime )

        {

        delete iCRAutoLockTime;

        iCRAutoLockTime = NULL;

        }

    if ( iCRAutoLockStatus )

        {

        delete iCRAutoLockStatus;

        iCRAutoLockStatus = NULL;

        }

    // PuSub observers

    if ( iPSAutolockState )

        {

        delete iPSAutolockState;

        iPSAutolockState = NULL;

        }

    if ( iContainer )

        {

        delete iContainer;

        iContainer = NULL;

        }

    }

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

// Devicelock UI constructor reserves localized resources, configures itself

// using CenRep and FeatureManager and reserves child controls.

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

void CLockAppDevicelockControl::ConstructL( RWindowGroup& aWg )

    {

    INFO( "CLockAppDevicelockControl::ConstructL started" );

    CLockAppBaseControl::ConstructL( );

    // feature manager is used for determining if the phone is a slider

    FeatureManager::InitializeLibL( );

    iFeatureProtocolCdma = FeatureManager::FeatureSupported( KFeatureIdProtocolCdma );

    INFO_1("CLockAppDevicelockControl::ConstructL - iFeatureProtocolCdma: %d", iFeatureProtocolCdma);

    FeatureManager::UnInitializeLib( );

    // Cba control

    iCba = CEikButtonGroupContainer::NewL( CEikButtonGroupContainer::ECba,

            CEikButtonGroupContainer::EHorizontal, this,

            R_KEYLOCK_SOFTKEYS_UNLOCK_EMPTY );

    TRect screenRect;

    AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EScreen, screenRect );

    iCba->SetBoundingRect( screenRect );

    iCba->MakeVisible( EFalse );

    // Set up the status pane

    CEikStatusPane* sp = iAvkonAppUi->StatusPane();

    if ( sp )

        {

        // Switch the layout to show analog clock

        TRAPD(err, sp->SwitchLayoutL( R_AVKON_STATUS_PANE_LAYOUT_IDLE ) )

        ERROR(err, "CLockAppDevicelockControl::ConstructL - failed to switch status pane layout");

        if ( sp->PaneCapabilities(TUid::Uid(EEikStatusPaneUidTitle)).IsPresent( ) )

            {

            // Get the title pane control from status pane

            CAknTitlePane* titlePane = NULL;

            TRAPD(err2, titlePane = static_cast<CAknTitlePane*>( sp->ControlL( TUid::Uid( EEikStatusPaneUidTitle) ) ) )

            ERROR(err2, "CLockAppDevicelockControl::ConstructL - failed to get status title pane");

            if ( titlePane )

                {

                // Read localized "Locked" text from resource.

                HBufC* lockedString = iCoeEnv->AllocReadResourceL( R_TITLE_PANE_LOCKED );

                // Set as title pane text - titlepane takes ownership of the string

                titlePane->SetText( lockedString );

                }

            }

        }

    INFO( "CLockAppDevicelockControl::ConstructL completed" );

    }

void CLockAppDevicelockControl::ConnectToPhoneL( RWindowGroup& aWg )

		{

    INFO( "CLockAppDevicelockControl::ConnectToPhoneL - connecting to etel server" );

    // All server connections are tried to be made KTiesToConnectServer times because

    // occasional fails on connections are possible at least on some servers

    TInt err( KErrGeneral);

    TInt thisTry( 0);

    while ( ( err = iTelServer.Connect() ) != KErrNone && ( thisTry++ ) <= KTriesToConnectServer )

        {

        User::After( KTimeBeforeRetryingServerConnection );

        }

    ERROR(err, "CLockAppDevicelockControl::ConnectToPhoneL - connecting to etel server");

    User::LeaveIfError( err );

    RDebug::Printf( "%s %s (%u) iTelServerInitialized=%x -> 2 ", __FILE__, __PRETTY_FUNCTION__, __LINE__, iTelServerInitialized );

    iTelServerInitialized=2;

    /*****************************************************

    *    S60 Customer / ETel

    *    S60  ETel API

    *****************************************************/

    /*****************************************************

    *    S60 Customer / TSY

    *    Needs customer TSY implementation

    *****************************************************/

    INFO( "CLockAppDevicelockControl::ConnectToPhoneL - loading TSY");

    err = iTelServer.LoadPhoneModule( KMmTsyModuleName );

    if ( err != KErrAlreadyExists )

        {

        // may return also KErrAlreadyExists if some other

        // is already loaded the tsy module. And that is not an error.

        ERROR(err, "CLockAppDevicelockControl::ConnectToPhoneL - loading TSY");

        User::LeaveIfError( err );

        }

    RDebug::Printf( "%s %s (%u) iTelServerInitialized=%x -> 3 ", __FILE__, __PRETTY_FUNCTION__, __LINE__, iTelServerInitialized );

    iTelServerInitialized=3;

    /*****************************************************

    *    S60 Customer / ETel

    *    S60  ETel API

    *****************************************************/

    INFO( "CLockAppDevicelockControl::ConnectToPhoneL - opening phone");

    RTelServer::TPhoneInfo PhoneInfo;

    User::LeaveIfError( iTelServer.SetExtendedErrorGranularity( RTelServer::EErrorExtended ) );

    RDebug::Printf( "%s %s (%u) iTelServerInitialized=%x -> 5 ", __FILE__, __PRETTY_FUNCTION__, __LINE__, iTelServerInitialized );

    iTelServerInitialized=5;

    User::LeaveIfError( iTelServer.GetPhoneInfo( KPhoneIndex, PhoneInfo ) );

    RDebug::Printf( "%s %s (%u) iTelServerInitialized=%x -> 6 ", __FILE__, __PRETTY_FUNCTION__, __LINE__, iTelServerInitialized );

    iTelServerInitialized=6;

    User::LeaveIfError( iPhone.Open( iTelServer, PhoneInfo.iName ) );

		RDebug::Printf( "%s %s (%u) iPhoneInitialized=%x -> 2 ", __FILE__, __PRETTY_FUNCTION__, __LINE__, iPhoneInitialized );

		iPhoneInitialized=2;

    User::LeaveIfError( iCustomPhone.Open( iPhone ) );

		RDebug::Printf( "%s %s (%u) iCustomPhoneInitialized=%x -> 2 ", __FILE__, __PRETTY_FUNCTION__, __LINE__, iCustomPhoneInitialized );

		iCustomPhoneInitialized=2;

    INFO( "CLockAppDevicelockControl::ConnectToPhoneL - phone opened");

    TBool systemLocked(EFalse);

    // Set up CenRep observers

    iCRAutoLockTime = CLockAppCenRepObserver::NewL(this, KCRUidSecuritySettings, KSettingsAutoLockTime);

    iCRAutoLockStatus = CLockAppCenRepObserver::NewL(this, KCRUidSecuritySettings, KSettingsAutolockStatus);

    #ifndef __WINS__

    /*****************************************************

    *    S60 Customer / ETel

    *    S60 ETel API

    *****************************************************/

    RMobilePhone::TMobilePhoneLock lockType = RMobilePhone::ELockPhoneDevice;

    RMobilePhone::TMobilePhoneLockInfoV1 lockInfo;

    RMobilePhone::TMobilePhoneLockInfoV1Pckg lockInfoPkg(lockInfo);

    TRequestStatus getLockInfoStatus;

    iPhone.GetLockInfo( getLockInfoStatus, lockType, lockInfoPkg );

		RDebug::Printf( "%s %s (%u) iPhoneInitialized=%x -> 3 ", __FILE__, __PRETTY_FUNCTION__, __LINE__, iPhoneInitialized );

		iPhoneInitialized=3;

    User::WaitForRequest( getLockInfoStatus );

    TInt lockValue(0);

    TInt cRresult = iCRAutoLockStatus->GetValue( lockValue );

    INFO_2( "CLockAppDevicelockControl::ConnectToPhoneL - CR autolockstatus=%d , res=%d", lockValue, cRresult);

    TBool hiddenReset = IsHiddenReset( );

    INFO_1( "CLockAppDevicelockControl::ConnectToPhoneL - hiddenReset=%d", hiddenReset );

    if ( lockInfo.iSetting == RMobilePhone::ELockSetDisabled )

        {

        INFO( "CLockAppDevicelockControl::ConnectToPhoneL - ELockSetDisabled");

        iCRAutoLockTime->SetValue( 0 );

        if ( iFeatureProtocolCdma )

            {

            iCRAutoLockTime->SetKeyValue( KSettingsLockOnPowerUp, 0 );

            }

        }

    else

        {

        if ( iFeatureProtocolCdma || (hiddenReset && (lockValue == 1)) )

            {

            // In CDMA, the system can stay locked on after the boot-up sequence.

            INFO( "CLockAppDevicelockControl::ConnectToPhoneL - Hidden reset when locked");

            systemLocked = ETrue;

            }

        }

    #endif //__WINS__

    // Create devicelock UI container

    INFO_1( "CLockAppDevicelockControl::ConnectToPhoneL - creating CLockAppDevicelockContainer=%d", 1 );

    iContainer = CLockAppDevicelockContainer::NewL( aWg );

    INFO_1( "CLockAppDevicelockControl::ConnectToPhoneL - creating CLockAppDevicelockContainer=%d done", 1 );

    INFO_1( "CLockAppDevicelockControl::ConnectToPhoneL - creating DefinePubSubKeysL=%d", 1 );

    DefinePubSubKeysL( );

    INFO_1( "CLockAppDevicelockControl::ConnectToPhoneL - creating DefinePubSubKeysL=%d", 1 );

    // The following sequence is used to validate the configuration on SCP server.

    // This is needed on the first boot (initial or RFS) or if the C-drive

    // has been formatted (3-button format) and Autolock is not active.

#ifdef __SAP_TERMINAL_CONTROL_FW

		// This seems to be defined always.

    INFO( "CLockAppDevicelockControl::ConnectToPhoneL - Validate SCP Config" );

    RSCPClient scpClient;

    if ( scpClient.Connect() == KErrNone )

        {

        CleanupClosePushL( scpClient );

        TInt confStatus = scpClient.CheckConfiguration( KSCPInitial );

        if ( confStatus == KErrAccessDenied )

            {

#ifndef __WINS__

            if ( ( lockInfo.iSetting == RMobilePhone::ELockSetDisabled ) )

#else // __WINS__

            if ( ETrue ) // DOS lock is never active in WINS

#endif // __WINS__

                {

                // DOS lock is not active. Note that if DOS is locked, checking the code here will

                // mess up the query sequence. On initial startup DOS is not locked.

                TInt finalConfStatus = scpClient.CheckConfiguration( KSCPComplete );

                if ( finalConfStatus == KErrAccessDenied )

                    {

#ifdef __WINS__

                    ERROR(finalConfStatus, "CLockAppDevicelockControl::ConnectToPhoneL - DOS validation FAILED in WINS!");

#else // !__WINS__

                    // The SCP server is out of sync and Autolock is not active. (c-drive formatted)

                    // We must ask the security code. ( Note that it is very rare that this is executed )

                    INFO( "CLockAppDevicelockControl::ConnectToPhoneL - Lock setting disabled, calling setlocksetting");

                    // Wait here until the startup is complete

                    TInt tarmErr(KErrNone);

                    while ( tarmErr == KErrNone )

                        {

                        TInt sysState;

                        tarmErr = RProperty::Get(KPSUidStartup, KPSGlobalSystemState, sysState);

                        if ((sysState == ESwStateNormalRfOn) ||

                            (sysState == ESwStateNormalRfOff) ||

                            (sysState == ESwStateNormalBTSap))

                            {

                            break;

                            }

                        User::After(500000); // half a second

                        }

                    // Just change the lock setting again to disabled to request the security code.

                    // Set the TARM flag so SecUi knows it should display the "login" query.

                    TInt tarmFlag;

                    TInt tRet = RProperty::Get( KSCPSIDAutolock, SCP_TARM_ADMIN_FLAG_UID, tarmFlag );

                    if ( tRet == KErrNone )

                        {

                        tarmFlag |= KSCPFlagResyncQuery;

                        tRet = RProperty::Set( KSCPSIDAutolock, SCP_TARM_ADMIN_FLAG_UID, tarmFlag );

                        }

                    ERROR(tRet, "CLockAppDevicelockControl::ConnectToPhoneL - FAILED to set TARM Admin Flag" );

                    TRequestStatus setLockSettingStatus;

                    RMobilePhone::TMobilePhoneLockSetting lockChange = RMobilePhone::ELockSetDisabled;

                    iPhone.SetLockSetting( setLockSettingStatus, lockType, lockChange );

                    User::WaitForRequest( setLockSettingStatus );

#endif // __WINS__

                    }

                }

            }

        CleanupStack::PopAndDestroy(); // calls Close() on scpClient

        }

#endif // __SAP_TERMINAL_CONTROL_FW

    // Set up P&S observers

    iPSAutolockState = CLockAppPubSubObserver::NewL( this, KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus );

    if ( systemLocked )

        {

        INFO( "CLockAppDevicelockControl::ConnectToPhoneL - Lock system");

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

        iStateControl.EnableDevicelockL( EDevicelockManual );

        INFO( "CLockAppDevicelockControl::ConnectToPhoneL - Lock system. Done");

        }

    // Activity manager

    iActivityManager = CUserActivityManager::NewL( CActive::EPriorityStandard );

    StartActivityMonitoringL( );

    // Setup key pattern matcher

    if ( !SetupKeyPatternsWithPolicyL( EPolicyDevicelockQuery ) )

        {

        INFO( "CLockAppDevicelockControl::ConnectToPhoneL - No CenRep policy defined" );

        iKeyPattern->AddPattern( EStdKeyDevice0, 0 ); // '0' = second key code doesnt matter

        }

#ifdef __WINS__

    iKeyPattern->AddPattern( EStdKeyDevice0, 0 ); // LSK + *

#endif

    INFO( "CLockAppDevicelockControl::ConstructL completed" );

    }

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

// Define internal P&S autolock status key

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

void CLockAppDevicelockControl::DefinePubSubKeysL()

    {

    INFO( "CLockAppDevicelockControl::DefinePubSubKeysL" );

    // Create the write policy. Also processes with write device data can write the value.

    TSecurityPolicy writePolicy( ECapabilityWriteDeviceData );

    // Create the read policy. Also processes with read device data can read the value.

    TSecurityPolicy readPolicy( ECapabilityReadDeviceData );

    TInt ret = RProperty::Define( KPSUidSecurityUIs,

            KSecurityUIsSecUIOriginatedQuery, RProperty::EInt, readPolicy, writePolicy );

    ERROR(ret, "CLockAppDevicelockControl::DefinePubSubKeysL - FAILED to define the SECUI query Flag");

    ret = RProperty::Define( KPSUidSecurityUIs,

            KSecurityUIsQueryRequestCancel, RProperty::EInt, readPolicy, writePolicy );

    ERROR(ret, "CLockAppDevicelockControl::DefinePubSubKeysL - FAILED to define the SECUI query request state Flag");

    _LIT_SECURITY_POLICY_PASS(KReadPolicy);

    _LIT_SECURITY_POLICY_C1(KWritePolicy, ECapabilityWriteDeviceData);

    ret = RProperty::Define( KPSUidCoreApplicationUIs,

            KCoreAppUIsAutolockStatus, RProperty::EInt, KReadPolicy, KWritePolicy);

    RProperty::Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, EAutolockOff);

    if (ret != KErrAlreadyExists)

        {

        ERROR(ret, "CLockAppDevicelockControl::DefinePubSubKeysL - FAILED to set autolock status");

        User::LeaveIfError(ret);

        }

    #ifdef __SAP_TERMINAL_CONTROL_FW

    // Define the TARM admin flag.

    ret = RProperty::Define( KSCPSIDAutolock,

            SCP_TARM_ADMIN_FLAG_UID, RProperty::EInt, readPolicy, writePolicy );

    ERROR(ret, "CLockAppDevicelockControl::DefinePubSubKeysL - FAILED to define the TARM Admin Flag");

    #endif // __SAP_TERMINAL_CONTROL_FW

    }

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

// Checks whether we are booting from a Hidden Reset

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

TBool CLockAppDevicelockControl::IsHiddenReset( )

    {

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

    TBool ret( EFalse );

    TInt startupReason( ENormalStartup );

    TInt err( KErrNone);

    err = RProperty::Get( KPSUidStartup, KPSStartupReason, startupReason );

    ERROR(err, "CLockAppDevicelockControl::IsHiddenReset - error getting startup reason" );

    ret = (startupReason != ENormalStartup);

    INFO_1( "CLockAppDevicelockControl::IsHiddenReset = %d", ret );

		#ifdef _DEBUG

			// test to simulate HiddenReset

			RFs fs;

			_LIT(KTestHiddenReset,"f:\\TestHiddenReset.txt");

			RFile file;

			User::LeaveIfError(fs.Connect());

			err=file.Open(fs, KTestHiddenReset, EFileStreamText|EFileRead|EFileShareReadersOnly);

			if(err==KErrNone)

				{

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

				ret = ETrue;

				}

			file.Close();

			fs.Close();

		#endif

    return ret;

    }

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

// Checks whether PIN1/UPIN is blocked

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

TBool CLockAppDevicelockControl::IsPinBlocked( )

    {

    INFO( "CLockAppDevicelockControl::IsPinBlocked" );

    TBool ret( EFalse );

    RMmCustomAPI::TSecurityCodeType secCodeType;

#if defined(__PROTOCOL_WCDMA) || defined(__UPIN)

    RMobilePhone::TMobilePhoneSecurityCode activePin;

    iCustomPhone.GetActivePin( activePin );

    if ( activePin == RMobilePhone::ESecurityUniversalPin )

        secCodeType = RMmCustomAPI::ESecurityUniversalPin;

    else

        secCodeType = RMmCustomAPI::ESecurityCodePin1;

#else

    secCodeType = RMmCustomAPI::ESecurityCodePin1;

#endif //(__PROTOCOL_WCDMA) || defined(__UPIN)

    iCustomPhone.IsBlocked( secCodeType, ret );

    INFO_1( "CLockAppDevicelockControl::IsPinBlocked = %d", ret );

    return ret;

    }

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

// Try to get (and optionally unset) the TARM Admin Flag

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

TBool CLockAppDevicelockControl::TarmAdminFlag( TBool unSetFlag )

    {

    INFO_1( "CLockAppDevicelockControl::TarmAdminFlag(unSet = %d)", unSetFlag );

    TBool ret(EFalse);

#ifdef __SAP_TERMINAL_CONTROL_FW

    // Get the TARM admin flag value

    TInt tarmFlag;

    TInt err = RProperty::Get( KSCPSIDAutolock, SCP_TARM_ADMIN_FLAG_UID, tarmFlag );

    if ( err != KErrNone )

        {

        ERROR(err, "CLockAppDevicelockControl::TarmAdminFlag - Failed to get TARM flag" );

        }

    else

        {

        INFO_1( "CLockAppDevicelockControl::TarmAdminFlag - TARM flag: %d", tarmFlag );